@playcanvas/attribute-parser 1.3.3 → 1.5.0

package/package.json

@@ -5,7 +5,7 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "version": "1.3.3",
+  "version": "1.5.0",
   "dependencies": {
     "@playcanvas/eslint-config": "^1.7.4 || ^2.0.0",
     "@typescript/vfs": "^1.6.0",

package/rollup.config.js

@@ -22,7 +22,12 @@ export default {
             preferBuiltins: false // Prefer the local versions of built-ins instead of Node.js versions
         }),
         swc({ swc: {
-            minify: true
+            minify: true,
+            jsc: {
+                minify: {
+                    compress: true
+                }
+            }
         } })
     ]
 };

package/src/parsers/attribute-parser.js

@@ -154,7 +154,7 @@ export class AttributeParser {
 
                         // Check if the declaration is a TypeScript enum
                         if (ts.isEnumDeclaration(declaration)) {
-                            members = declaration.members.map(member => ({ [member.name.getText()]: member.initializer.text }));
+                            members = declaration.members.map(member => ({ [member.name.text]: member.initializer.text }));
                         }
 
                         // Additionally check for JSDoc enum tag
@@ -187,7 +187,8 @@ export class AttributeParser {
             node.properties.forEach((property) => {
 
                 if (ts.isPropertyAssignment(property)) {
-                    const name = property.name && ts.isIdentifier(property.name) && property.name.text;
+                    const isValidName = ts.isIdentifier(property.name) || ts.isStringLiteral(property.name);
+                    const name = isValidName && property.name.text;
                     const value = getLiteralValue(property.initializer, this.typeChecker);
                     members.push({ [name]: value });
                 }

package/src/parsers/script-parser.js

@@ -147,7 +147,9 @@ const SUPPORTED_BLOCK_TAGS = new Map([
     ['size', 'number'],
     ['step', 'number'],
     ['title', 'string'],
-    ['default', 'any']
+    ['default', 'any'],
+    ['enabledif', 'any'],
+    ['visibleif', 'any']
 ]);
 
 /**
@@ -202,6 +204,16 @@ const mapAttributesToOutput = (attribute) => {
         delete attribute.default;
     }
 
+    // enabledif is in a {}, so strip it out
+    if (attribute.enabledif?.startsWith('{') && attribute.enabledif?.endsWith('}')) {
+        attribute.enabledif = attribute.enabledif.slice(1, -1);
+    }
+
+    // enabledif is in a {}, so strip it out
+    if (attribute.visibleif?.startsWith('{') && attribute.visibleif?.endsWith('}')) {
+        attribute.visibleif = attribute.visibleif.slice(1, -1);
+    }
+
     // remove typeName from the output
     delete attribute.typeName;
     delete attribute.value;

package/test/fixtures/conditional.valid.js

@@ -0,0 +1,22 @@
+import { Script } from 'playcanvas';
+
+class Example extends Script {
+    /**
+     * @attribute
+     * @visibleif {b === 2}
+     */
+    a = 1;
+
+    /**
+     * @attribute
+     * @enabledif {a === 3}
+     */
+    b = 1;
+
+    /**
+     * @attribute
+     */
+    c = 1;
+}
+
+export { Example };

package/test/fixtures/enum.valid.js

@@ -16,7 +16,8 @@ const NumberEnum = {
 const StringEnum = {
     A: 'a',
     B: 'b',
-    C: 'c'
+    C: 'c',
+    'A string key': 'd'
 };
 
 /**

package/test/fixtures/enum.valid.ts

@@ -9,7 +9,8 @@ enum NumberEnum {
 enum StringEnum {
     A = 'a',
     B = 'b',
-    C = 'c'
+    C = 'c',
+    "A string key" = 'd'
 };
 
 enum NumberNumberEnum {

package/test/tests/valid/conditional.test.js

@@ -0,0 +1,45 @@
+import { expect } from 'chai';
+import { describe, it, before } from 'mocha';
+
+import { parseAttributes } from '../../utils.js';
+
+describe('VALID: Conditional Tags', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./conditional.valid.js');
+    });
+
+    it('only results should exist', function () {
+        expect(data).to.exist;
+        expect(data[0]).to.not.be.empty;
+        expect(data[1]).to.be.empty;
+    });
+
+    it('Example: should exist without errors', function () {
+        expect(data[0]?.example).to.exist;
+        expect(data[0].example.attributes).to.not.be.empty;
+        expect(data[0].example.errors).to.be.empty;
+    });
+
+    it('a: should conditional `@visibleif` tag', function () {
+        expect(data[0].example.attributes.a).exist;
+        expect(data[0].example.attributes.a.name).to.equal('a');
+        expect(data[0].example.attributes.a.type).to.equal('number');
+        expect(data[0].example.attributes.a.visibleif).to.equal('b === 2');
+    });
+
+    it('b: should conditional `@enabledif` tag', function () {
+        expect(data[0].example.attributes.b).exist;
+        expect(data[0].example.attributes.b.name).to.equal('b');
+        expect(data[0].example.attributes.b.type).to.equal('number');
+        expect(data[0].example.attributes.b.enabledif).to.equal('a === 3');
+    });
+
+    it('c: should not include `@enabledif` or `@visibleif` tag if none is declared', function () {
+        expect(data[0].example.attributes.c).exist;
+        expect(data[0].example.attributes.c.name).to.equal('c');
+        expect(data[0].example.attributes.c.type).to.equal('number');
+        expect(data[0].example.attributes.c.enabledif).to.not.exist;
+        expect(data[0].example.attributes.c.visibleif).to.not.exist;
+    });
+});

package/test/tests/valid/enum.test.js

@@ -56,10 +56,11 @@ function runTests(fileName) {
             expect(data[0].example.attributes.h.name).to.equal('h');
             expect(data[0].example.attributes.h.type).to.equal('string');
             expect(data[0].example.attributes.h.array).to.equal(false);
-            expect(data[0].example.attributes.h.enum).to.be.an('array').with.lengthOf(3);
+            expect(data[0].example.attributes.h.enum).to.be.an('array').with.lengthOf(4);
             expect(data[0].example.attributes.h.enum[0]).to.deep.equal({ A: 'a' });
             expect(data[0].example.attributes.h.enum[1]).to.deep.equal({ B: 'b' });
             expect(data[0].example.attributes.h.enum[2]).to.deep.equal({ C: 'c' });
+            expect(data[0].example.attributes.h.enum[3]).to.deep.equal({ 'A string key': 'd' });
             expect(data[0].example.attributes.h.default).to.equal('');
         });