Add support for external references (#61)

* feat: enhance enum handling and add playcanvas dependency

- Updated the attribute parser to correctly handle TypeScript enums, including imported constants.
- Enhanced the getLiteralValue function to prioritize type checking for imported constants.
- Added support for enums in the test fixtures, validating the integration with playcanvas.
- Introduced playcanvas as a dependency in package.json and package-lock.json.

This update improves the parsing of enums and ensures compatibility with the latest playcanvas features.

* refactor: update enum handling and improve type resolution

- Replaced the fallback in `resolveIdentifier` to return `undefined` instead of a literal value.
- Refactored enum definitions in test fixtures to utilize new tone mapping constants from playcanvas.
- Updated tests to validate the new enum structure and ensure correct default values for tone mapping attributes.

This change enhances the clarity and functionality of enum handling in the codebase.

* feat: add Playcanvas types loading and remove fixture file

- Introduced a new function `getPlaycanvasTypes` to load Playcanvas type definitions directly from `node_modules`.
- Updated `parseAttributes` and `getAttributes` functions to utilize the loaded Playcanvas types instead of relying on a local fixture file.
- Removed the `playcanvas.d.ts` fixture file as it is no longer needed.

This change streamlines type handling and ensures that the latest Playcanvas definitions are used in the project.

Author: marklundin

package-lock.json

@@ -42,8 +42,9 @@
     "chai": "5.2.1",
     "globals": "16.3.0",
     "mocha": "11.7.1",
-    "rollup": "4.46.2",
-    "publint": "0.3.12"
+    "playcanvas": "^2.12.3",
+    "publint": "0.3.12",
+    "rollup": "4.46.2"
   },
   "dependencies": {
     "@playcanvas/eslint-config": "^2.0.0",

package.json

@@ -213,7 +213,14 @@ export class AttributeParser {
 
                         // Check if the declaration is a TypeScript enum
                         if (ts.isEnumDeclaration(declaration)) {
-                            members = declaration.members.map(member => ({ [member.name.text]: member.initializer.text }));
+                            members = declaration.members.map((member) => {
+                                const name = member.name.text;
+                                let value;
+                                if (member.initializer) {
+                                    value = getLiteralValue(member.initializer, this.typeChecker);
+                                }
+                                return { [name]: value };
+                            });
                         }
 
                         // Additionally check for JSDoc enum tag

src/parsers/attribute-parser.js

@@ -195,7 +195,7 @@ function getSuperClasses(node, typeChecker) {
         currentClass = superClassDeclaration;
     }
 
-    return superClasses; // .reverse(); // To return the array in order from the base class to the top-level class
+    return superClasses;
 }
 
 /**
@@ -293,20 +293,38 @@ export function isEnum(node) {
  */
 export function getPrimitiveEnumType(type, typeChecker) {
     // Check if the type is an enum type
-    if (!type.symbol?.declarations?.some(decl => ts.isEnumDeclaration(decl))) return null;
+    const isEnumType = type.symbol?.declarations?.some(decl => ts.isEnumDeclaration(decl));
 
-    // Get the type of enum members
-    const enumMembers = type.symbol.declarations[0].members;
-    const firstMemberValue = typeChecker.getConstantValue(enumMembers[0]);
+    // If not directly an enum, check if it's an enum member (which means it's part of an enum)
+    let isEnumMember = false;
+    if (!isEnumType) {
+        isEnumMember = type.symbol?.declarations?.some(decl => ts.isEnumMember(decl));
+        if (!isEnumMember) return null;
+    }
+
+    // Get the enum members
+    let enumMembers;
+    if (isEnumType) {
+        enumMembers = type.symbol.declarations[0].members;
+    } else if (isEnumMember) {
+        const enumMember = type.symbol.declarations[0];
+        const parentEnum = enumMember.parent;
+        if (ts.isEnumDeclaration(parentEnum)) {
+            enumMembers = parentEnum.members;
+        } else {
+            return null;
+        }
+    }
 
-    const validEnumType = [
-        'number',
-        'string',
-        'boolean'
-    ];
+    // Get the value of the first enum member using our centralized logic
+    const firstMember = enumMembers[0];
+    const firstMemberValue = firstMember.initializer ?
+        getLiteralValue(firstMember.initializer, typeChecker) :
+        getLiteralValue(firstMember, typeChecker);
 
+    const validEnumTypes = ['number', 'string', 'boolean'];
     const typeOf = typeof firstMemberValue;
-    return validEnumType.includes(typeOf) ? typeOf : null;
+    return validEnumTypes.includes(typeOf) ? typeOf : null;
 }
 
 /**
@@ -484,6 +502,8 @@ function resolveIdentifier(node, typeChecker) {
             // Handle other kinds of declarations if needed
         }
     }
+
+    // Fallback to getLiteralValue which now handles typeChecker approach
     return undefined;
 }
 
@@ -514,6 +534,12 @@ const resolvePropertyAccess = (node, typeChecker) => {
         }
     }
 
+    // Try getLiteralValue first (which now handles typeChecker approach)
+    const result = getLiteralValue(node, typeChecker);
+    if (result !== undefined) {
+        return result;
+    }
+
     // If symbol not found directly, attempt to resolve the object first
     const objValue = getLiteralValue(node.expression, typeChecker);
     if (objValue && typeof objValue === 'object') {
@@ -575,6 +601,14 @@ function handleObjectLiteral(node, typeChecker) {
 export function getLiteralValue(node, typeChecker) {
     if (!node) return undefined;
 
+    // Try typeChecker approach first for imported constants and other complex cases
+    if (typeChecker) {
+        const type = typeChecker.getTypeAtLocation(node);
+        if (type && type.isLiteral()) {
+            return type.value;
+        }
+    }
+
     if (ts.isLiteralExpression(node) || ts.isBooleanLiteral(node)) {
         if (ts.isStringLiteral(node)) {
             return node.text;

src/utils/ts-utils.js

@@ -1,4 +1,4 @@
-import { Script } from 'playcanvas';
+import { Script, TONEMAP_ACES, TONEMAP_ACES2, TONEMAP_FILMIC, TONEMAP_HEJL, TONEMAP_LINEAR, TONEMAP_NEUTRAL } from 'playcanvas';
 
 /**
  * @enum {number}
@@ -9,6 +9,18 @@ const NumberEnum = {
     C: 23
 };
 
+/**
+ * @enum {number}
+ */
+const ToneMapping = {
+    LINEAR: TONEMAP_LINEAR,
+    FILMIC: TONEMAP_FILMIC,
+    HEJL: TONEMAP_HEJL,
+    ACES: TONEMAP_ACES,
+    ACES2: TONEMAP_ACES2,
+    NEUTRAL: TONEMAP_NEUTRAL
+};
+
 /**
  * @enum {string}
  */
@@ -63,6 +75,12 @@ class Example extends Script {
      * @type {NumberNumberEnum}
      */
     i = 2;
+
+    /**
+     * @attribute
+     * @type {ToneMapping}
+     */
+    j = ToneMapping.LINEAR;
 }
 
 export { Example };

test/fixtures/enum.valid.js

@@ -1,4 +1,4 @@
-import { Script, Vec3 } from 'playcanvas';
+import { Script, Vec3, BODYGROUP_DEFAULT, TONEMAP_LINEAR, TONEMAP_NEUTRAL, TONEMAP_ACES2, TONEMAP_ACES, TONEMAP_HEJL, TONEMAP_FILMIC } from 'playcanvas';
 
 enum NumberEnum {
     A = 13,
@@ -19,6 +19,15 @@ enum NumberNumberEnum {
     C = NumberEnum.C
 };
 
+enum ToneMapping {
+    LINEAR = TONEMAP_LINEAR,
+    FILMIC = TONEMAP_FILMIC,
+    HEJL = TONEMAP_HEJL,
+    ACES = TONEMAP_ACES,
+    ACES2 = TONEMAP_ACES2,
+    NEUTRAL = TONEMAP_NEUTRAL
+};
+
 class Example extends Script {
     static scriptName = 'example';
 
@@ -47,6 +56,11 @@ class Example extends Script {
      * @attribute
      */
     i : NumberNumberEnum = 2;
+
+    /**
+     * @attribute
+     */
+    j : ToneMapping = ToneMapping.LINEAR;
 }
 
 export { Example };