@playcanvas/attribute-parser 1.0.0

package/test/fixtures/program.invalid.js

@@ -0,0 +1,11 @@
+import { Script } from 'playcanvas';
+
+class Example extends Script {
+    /**
+     * @attribute
+     * @type {boolean}
+     */
+    a = 10;
+}
+
+export { Example };

package/test/fixtures/text.valid.js

@@ -0,0 +1,30 @@
+import { Script } from 'playcanvas';
+
+class Example extends Script {
+    /**
+     * @attribute
+     * @type {string}
+     */
+    a;
+
+    /**
+     * @attribute
+     */
+    b = 'example';
+
+    /**
+     * @attribute
+     * @type {string}
+     * @placeholder Example text
+     */
+    c;
+
+    /**
+     * @attribute
+     * @type {string[]}
+     * @size 2
+     */
+    d;
+}
+
+export { Example };

package/test/fixtures/vector.invalid.js

@@ -0,0 +1,13 @@
+import { Script, Vec3 } from 'playcanvas';
+
+class Vec3Extended extends Vec3 {};
+
+class Example extends Script {
+    /**
+     * @attribute
+     * @type {Vec3Extended}
+     */
+    d;
+}
+
+export { Example };

package/test/fixtures/vector.valid.js

@@ -0,0 +1,23 @@
+import { Script, Vec2, Vec3, Vec4 } from 'playcanvas';
+
+class Example extends Script {
+    /**
+     * @attribute
+     * @type {Vec2}
+     */
+    a;
+
+    /**
+     * @attribute
+     */
+    b = new Vec3(1, 2, 3);
+
+    /**
+     * @attribute
+     * @type {Vec4[]}
+     * @size 2
+     */
+    c;
+}
+
+export { Example };

package/test/tests/invalid/asset.test.js

@@ -0,0 +1,48 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it, before } from 'mocha';
+import { expect } from 'chai';
+
+import { parseAttributes } from '../../utils.js';
+
+describe('INVALID: Asset attribute', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./asset.invalid.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 with errors (3)', function () {
+        expect(data[0]?.example).to.exist;
+        expect(data[0].example.attributes).to.not.be.empty;
+        expect(data[0].example.errors.length).to.equal(3);
+    });
+
+    it('a: should fallback to an asset attribute without resource', function () {
+        expect(data[0].example.attributes.a).to.exist;
+        expect(data[0].example.attributes.a.name).to.equal('a');
+        expect(data[0].example.attributes.a.type).to.equal('asset');
+        expect(data[0].example.attributes.a.default).to.not.exist;
+        expect(data[0].example.attributes.a.resource).to.not.exist;
+    });
+
+    it('b: should fallback to an asset attribute without resource', function () {
+        expect(data[0].example.attributes.b).to.exist;
+        expect(data[0].example.attributes.b.name).to.equal('b');
+        expect(data[0].example.attributes.b.type).to.equal('asset');
+        expect(data[0].example.attributes.b.default).to.not.exist;
+        expect(data[0].example.attributes.b.resource).to.not.exist;
+    });
+
+    it('c: should fallback to an asset attribute without resource', function () {
+        expect(data[0].example.attributes.c).to.exist;
+        expect(data[0].example.attributes.c.name).to.equal('c');
+        expect(data[0].example.attributes.c.type).to.equal('asset');
+        expect(data[0].example.attributes.c.default).to.not.exist;
+        expect(data[0].example.attributes.c.resource).to.not.exist;
+    });
+});

package/test/tests/invalid/curve.test.js

@@ -0,0 +1,24 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it, before } from 'mocha';
+import { expect } from 'chai';
+
+import { parseAttributes } from '../../utils.js';
+
+describe('INVALID: Curve attribute', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./curve.invalid.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 with errors (4)', function () {
+        expect(data[0]?.example).to.exist;
+        expect(data[0].example.attributes).to.not.be.empty;
+        expect(data[0].example.errors.length).to.equal(4);
+    });
+});

package/test/tests/invalid/json.test.js

@@ -0,0 +1,28 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it, before } from 'mocha';
+import { expect } from 'chai';
+
+import { parseAttributes } from '../../utils.js';
+
+describe('INVALID: JSON attribute', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./json.invalid.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 with errors (1)', function () {
+        expect(data[0]?.example).to.exist;
+        expect(data[0].example.attributes).to.be.empty;
+        expect(data[0].example.errors.length).to.equal(1);
+    });
+
+    it('o: should not be recognised as an attribute (type not an interface)', function () {
+        expect(data[0].example.attributes.o).to.not.exist;
+    });
+});

package/test/tests/invalid/misc.test.js

@@ -0,0 +1,42 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it, before } from 'mocha';
+import { expect } from 'chai';
+
+import { parseAttributes } from '../../utils.js';
+
+describe('INVALID: Misc attribute types', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./misc.invalid.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 with attributes and errors (4)', function () {
+        expect(data[0].example).to.exist;
+        expect(data[0].example.attributes).to.not.be.empty;
+        expect(data[0].example.errors.length).to.equal(3);
+    });
+
+    it('e: should not be recognised as an attribute (cannot infer GraphNode type)', function () {
+        expect(data[0].example.attributes.e).to.not.exist;
+    });
+
+    it('f: should not be recognised as an attribute (cannot infer custom Vec3 type)', function () {
+        expect(data[0].example.attributes.f).to.not.exist;
+    });
+
+    it('g: should fallback to a numeric attribute array without size', function () {
+        expect(data[0].example.attributes.g).to.exist;
+        expect(data[0].example.attributes.g.name).to.equal('g');
+        expect(data[0].example.attributes.g.type).to.equal('number');
+        expect(data[0].example.attributes.g.array).to.equal(true);
+        expect(data[0].example.attributes.g.default).to.not.exist;
+        expect(data[0].example.attributes.g.size).to.not.exist;
+    });
+
+});

package/test/tests/invalid/numeric.test.js

@@ -0,0 +1,56 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it, before } from 'mocha';
+import { expect } from 'chai';
+
+import { parseAttributes } from '../../utils.js';
+
+describe('INVALID: Numeric attribute', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./numeric.invalid.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 with attributes and errors (6)', function () {
+        expect(data[0]?.example).to.exist;
+        expect(data[0].example.attributes).to.not.be.empty;
+        expect(data[0].example.errors.length).to.equal(6);
+    });
+
+    it('a: should fallback to a numeric attribute without range', function () {
+        expect(data[0].example.attributes.a).to.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.array).to.equal(false);
+        expect(data[0].example.attributes.a.default).to.equal(0);
+        expect(data[0].example.attributes.a.min).to.not.exist;
+        expect(data[0].example.attributes.a.max).to.not.exist;
+    });
+
+    it('b: should not be recognised as an attribute (step tag dropped)', function () {
+        expect(data[0].example.attributes.b).to.not.exist;
+    });
+
+    it('c: should not be recognised as an attribute (precision tag dropped)', function () {
+        expect(data[0].example.attributes.c).to.not.exist;
+    });
+
+    it('d: should fallback to a numeric attribute without step and precision', function () {
+        expect(data[0].example.attributes.d).to.exist;
+        expect(data[0].example.attributes.d.name).to.equal('d');
+        expect(data[0].example.attributes.d.type).to.equal('number');
+        expect(data[0].example.attributes.d.array).to.equal(false);
+        expect(data[0].example.attributes.d.step).to.not.exist;
+        expect(data[0].example.attributes.d.precision).to.not.exist;
+    });
+
+    it('e: should not be recognised as an attribute (step tag dropped)', function () {
+        expect(data[0].example.attributes.e).to.exist;
+        expect(data[0].example.attributes.e.step).to.not.exist;
+    });
+});

package/test/tests/invalid/program.test.js

@@ -0,0 +1,18 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it, before } from 'mocha';
+import { expect } from 'chai';
+
+import { parseAttributes } from '../../utils.js';
+
+describe('INVALID: Program ', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./program.invalid.js');
+    });
+
+    it('only errors should exist (1)', function () {
+        expect(data).to.exist;
+        expect(data[0]).to.be.empty;
+        expect(data[1].length).to.equal(1);
+    });
+});

package/test/tests/invalid/vector.test.js

@@ -0,0 +1,29 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it, before } from 'mocha';
+import { expect } from 'chai';
+
+import { parseAttributes } from '../../utils.js';
+
+describe('INVALID: Vector attribute', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./vector.invalid.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 with errors (1)', function () {
+        expect(data[0]?.example).to.exist;
+        expect(data[0].example.attributes).to.be.empty;
+        expect(data[0].example.errors.length).to.equal(1);
+    });
+
+    it('d: should not be recognized as an attribute (extends vector and not is vector)', function () {
+        expect(data[0].example.attributes.d).to.not.exist;
+    });
+
+});

package/test/tests/valid/asset.test.js

@@ -0,0 +1,51 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it, before } from 'mocha';
+import { expect } from 'chai';
+
+import { parseAttributes } from '../../utils.js';
+
+describe('VALID: Asset attribute', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./asset.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 be a asset attribute', function () {
+        expect(data[0].example.attributes.a).to.exist;
+        expect(data[0].example.attributes.a.name).to.equal('a');
+        expect(data[0].example.attributes.a.type).to.equal('asset');
+        expect(data[0].example.attributes.a.array).to.equal(false);
+        expect(data[0].example.attributes.a.default).to.equal(null);
+    });
+
+    it('b: should be a asset attribute with a texture resource', function () {
+        expect(data[0].example.attributes.b).to.exist;
+        expect(data[0].example.attributes.b.name).to.equal('b');
+        expect(data[0].example.attributes.b.type).to.equal('asset');
+        expect(data[0].example.attributes.b.array).to.equal(false);
+        expect(data[0].example.attributes.b.default).to.equal(null);
+        expect(data[0].example.attributes.b.resource).to.equal('texture');
+    });
+
+    it('c: should be a asset attribute array with a container resource', function () {
+        expect(data[0].example.attributes.c).to.exist;
+        expect(data[0].example.attributes.c.name).to.equal('c');
+        expect(data[0].example.attributes.c.type).to.equal('asset');
+        expect(data[0].example.attributes.c.array).to.equal(true);
+        expect(data[0].example.attributes.c.default).to.equal(null);
+        expect(data[0].example.attributes.c.resource).to.equal('container');
+    });
+
+});

package/test/tests/valid/checkbox.test.js

@@ -0,0 +1,50 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it, before } from 'mocha';
+import { expect } from 'chai';
+
+import { parseAttributes } from '../../utils.js';
+
+describe('VALID: Checkbox attribute', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./checkbox.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 be a checkbox attribute', function () {
+        expect(data[0].example.attributes.a).to.exist;
+        expect(data[0].example.attributes.a.name).to.equal('a');
+        expect(data[0].example.attributes.a.type).to.equal('boolean');
+        expect(data[0].example.attributes.a.array).to.equal(false);
+        expect(data[0].example.attributes.a.default).to.equal(false);
+    });
+
+    it('b: should be a checkbox attribute with a default value', function () {
+        expect(data[0].example.attributes.b).to.exist;
+        expect(data[0].example.attributes.b.name).to.equal('b');
+        expect(data[0].example.attributes.b.type).to.equal('boolean');
+        expect(data[0].example.attributes.b.array).to.equal(false);
+        expect(data[0].example.attributes.b.default).to.equal(true);
+    });
+
+    it('c: should be a checkbox attribute array with a size', function () {
+        expect(data[0].example.attributes.c).to.exist;
+        expect(data[0].example.attributes.c.name).to.equal('c');
+        expect(data[0].example.attributes.c.type).to.equal('boolean');
+        expect(data[0].example.attributes.c.array).to.equal(true);
+        expect(data[0].example.attributes.c.size).to.equal(2);
+        expect(data[0].example.attributes.c.default).equal(null);
+    });
+
+});

package/test/tests/valid/color.test.js

@@ -0,0 +1,50 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it, before } from 'mocha';
+import { expect } from 'chai';
+
+import { parseAttributes } from '../../utils.js';
+
+describe('VALID: Color attribute', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./color.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 be a color attribute', function () {
+        expect(data[0].example.attributes.a).to.exist;
+        expect(data[0].example.attributes.a.name).to.equal('a');
+        expect(data[0].example.attributes.a.type).to.equal('rgba');
+        expect(data[0].example.attributes.a.array).to.equal(false);
+        expect(data[0].example.attributes.a.default).to.eql([1, 1, 1, 1]);
+    });
+
+    it('b: should be a color attribute with a default value', function () {
+        expect(data[0].example.attributes.b).to.exist;
+        expect(data[0].example.attributes.b.name).to.equal('b');
+        expect(data[0].example.attributes.b.type).to.equal('rgba');
+        expect(data[0].example.attributes.b.array).to.equal(false);
+        expect(data[0].example.attributes.b.default).to.eql([1, 0, 0, 1]);
+    });
+
+    it('c: should be a color attribute array with a size', function () {
+        expect(data[0].example.attributes.c).to.exist;
+        expect(data[0].example.attributes.c.name).to.equal('c');
+        expect(data[0].example.attributes.c.type).to.equal('rgba');
+        expect(data[0].example.attributes.c.array).to.equal(true);
+        expect(data[0].example.attributes.c.size).to.equal(2);
+        expect(data[0].example.attributes.c.default).equal(null);
+    });
+
+});

package/test/tests/valid/curve.test.js

@@ -0,0 +1,77 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it, before } from 'mocha';
+import { expect } from 'chai';
+
+import { parseAttributes } from '../../utils.js';
+
+describe('VALID: Curve attribute', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./curve.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 be a curve attribute', 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('curve');
+        expect(data[0].example.attributes.a.array).to.equal(false);
+        expect(data[0].example.attributes.a.default).to.eql([]);
+    });
+
+    it('b: should be a curve attribute with a default value', 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('curve');
+        expect(data[0].example.attributes.b.array).to.equal(false);
+        expect(data[0].example.attributes.b.default).to.eql([0, 0, 1, 1]);
+    });
+
+    it('c: should be a curve attribute with a color', 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('curve');
+        expect(data[0].example.attributes.c.array).to.equal(false);
+        expect(data[0].example.attributes.c.default).to.eql([]);
+        expect(data[0].example.attributes.c.color).to.equal('r');
+    });
+
+    it('d: should be a curve attribute with a color and curve', function () {
+        expect(data[0].example.attributes.d).exist;
+        expect(data[0].example.attributes.d.name).to.equal('d');
+        expect(data[0].example.attributes.d.type).to.equal('curve');
+        expect(data[0].example.attributes.d.array).to.equal(false);
+        expect(data[0].example.attributes.d.default).to.eql([]);
+        expect(data[0].example.attributes.d.color).to.equal('rgb');
+        expect(data[0].example.attributes.d.curves).to.deep.equal(['x', 'y', 'z']);
+    });
+
+    it('e: should be a curve attribute array with a size', function () {
+        expect(data[0].example.attributes.e).exist;
+        expect(data[0].example.attributes.e.name).to.equal('e');
+        expect(data[0].example.attributes.e.type).to.equal('curve');
+        expect(data[0].example.attributes.e.array).to.equal(true);
+        expect(data[0].example.attributes.e.size).to.equal(2);
+        expect(data[0].example.attributes.e.default).equal(null);
+    });
+
+    it('f: should be a curve attribute in an unsual format', function () {
+        expect(data[0].example.attributes.f).exist;
+        expect(data[0].example.attributes.f.name).to.equal('f');
+        expect(data[0].example.attributes.f.type).to.equal('curve');
+        expect(data[0].example.attributes.f.array).to.equal(false);
+        expect(data[0].example.attributes.f.color).to.equal('rgba');
+        expect(data[0].example.attributes.f.curves).to.deep.equal(['x', 'y', 'z']);
+    });
+});

package/test/tests/valid/entity.test.js

@@ -0,0 +1,50 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it, before } from 'mocha';
+import { expect } from 'chai';
+
+import { parseAttributes } from '../../utils.js';
+
+describe('VALID: Entity attribute', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./entity.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 be a entity attribute', function () {
+        expect(data[0].example.attributes.a).to.exist;
+        expect(data[0].example.attributes.a.name).to.equal('a');
+        expect(data[0].example.attributes.a.type).to.equal('entity');
+        expect(data[0].example.attributes.a.array).to.equal(false);
+        expect(data[0].example.attributes.a.default).to.equal(null);
+    });
+
+    it('b: should be a entity attribute with a default value', function () {
+        expect(data[0].example.attributes.b).to.exist;
+        expect(data[0].example.attributes.b.name).to.equal('b');
+        expect(data[0].example.attributes.b.type).to.equal('entity');
+        expect(data[0].example.attributes.b.array).to.equal(false);
+        expect(data[0].example.attributes.b.default).to.equal(null);
+    });
+
+    it('c: should be a entity attribute array with a size', function () {
+        expect(data[0].example.attributes.c).to.exist;
+        expect(data[0].example.attributes.c.name).to.equal('c');
+        expect(data[0].example.attributes.c.type).to.equal('entity');
+        expect(data[0].example.attributes.c.array).to.equal(true);
+        expect(data[0].example.attributes.c.size).to.equal(2);
+        expect(data[0].example.attributes.c.default).equal(null);
+    });
+
+});