@playcanvas/attribute-parser 1.0.0

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

@@ -0,0 +1,74 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it, before } from 'mocha';
+import { expect } from 'chai';
+
+import { parseAttributes } from '../../utils.js';
+
+describe('VALID: Enum attribute', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./enum.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('e: should be a enum attribute', function () {
+        expect(data[0].example.attributes.e).to.exist;
+        expect(data[0].example.attributes.e.name).to.equal('e');
+        expect(data[0].example.attributes.e.type).to.equal('number');
+        expect(data[0].example.attributes.e.array).to.equal(false);
+        expect(data[0].example.attributes.e.default).to.equal(0);
+    });
+
+    it('f: should be a enum attribute with a default value', function () {
+        expect(data[0].example.attributes.f).to.exist;
+        expect(data[0].example.attributes.f.name).to.equal('f');
+        expect(data[0].example.attributes.f.type).to.equal('number');
+        expect(data[0].example.attributes.f.array).to.equal(false);
+        expect(data[0].example.attributes.f.default).to.equal(1);
+    });
+
+    it('g: should be a enum attribute array with a 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.size).to.equal(2);
+        expect(data[0].example.attributes.g.default).equal(null);
+    });
+
+    it('h: should be a enum attribute', function () {
+        expect(data[0].example.attributes.h).to.exist;
+        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.default).to.equal('');
+    });
+
+    it('i: should be a enum attribute with a default value', function () {
+        expect(data[0].example.attributes.i).to.exist;
+        expect(data[0].example.attributes.i.name).to.equal('i');
+        expect(data[0].example.attributes.i.type).to.equal('vec3');
+        expect(data[0].example.attributes.i.array).to.equal(false);
+        expect(data[0].example.attributes.i.default).to.eql([0, 0, 0]);
+    });
+
+    it('j: should be a enum attribute array with a size', function () {
+        expect(data[0].example.attributes.j).to.exist;
+        expect(data[0].example.attributes.j.name).to.equal('j');
+        expect(data[0].example.attributes.j.type).to.equal('number');
+        expect(data[0].example.attributes.j.array).to.equal(false);
+        expect(data[0].example.attributes.j.default).equal(2);
+    });
+
+});

package/test/tests/valid/export.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('VALID: Export Script', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./export.valid.js', './export.import.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 attributes or errors', function () {
+        expect(data[0]?.example).to.exist;
+        expect(data[0].example.attributes).to.be.empty;
+        expect(data[0].example.errors).to.be.empty;
+    });
+
+    it('ExampleExport: should exist without attributes or errors', function () {
+        expect(data[0]?.exampleExport).to.exist;
+        expect(data[0].exampleExport.attributes).to.be.empty;
+        expect(data[0].exampleExport.errors).to.be.empty;
+    });
+
+    it('ExampleDefault: should exist without attributes or errors', function () {
+        expect(data[0]?.exampleDefault).to.exist;
+        expect(data[0].exampleDefault.attributes).to.be.empty;
+        expect(data[0].exampleDefault.errors).to.be.empty;
+    });
+
+    it('ExampleExportAs: should not exist', function () {
+        expect(data[0]?.exampleExportAs).to.not.exist;
+    });
+
+    it('ExampleImport: should exist without attributes or errors', function () {
+        expect(data[0]?.exampleImport).to.exist;
+        expect(data[0].exampleImport.attributes).to.be.empty;
+        expect(data[0].exampleImport.errors).to.be.empty;
+    });
+
+    it('ExampleImportExtend: should exist without attributes or errors', function () {
+        expect(data[0]?.exampleImportExtend).to.exist;
+        expect(data[0].exampleImportExtend.attributes).to.be.empty;
+        expect(data[0].exampleImportExtend.errors).to.be.empty;
+    });
+
+    it('ExampleNotExported: should not exist (not exported)', function () {
+        expect(data[0]?.exampleNotExported).to.not.exist;
+    });
+});

package/test/tests/valid/inherit.test.js

@@ -0,0 +1,103 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it, before } from 'mocha';
+import { expect } from 'chai';
+
+import { parseAttributes } from '../../utils.js';
+
+describe('VALID: Script inheritance attributes', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./inherit.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('ExampleExtended: should exist without errors', function () {
+        expect(data[0]?.exampleExtended).to.exist;
+        expect(data[0].exampleExtended.attributes).to.not.be.empty;
+        expect(data[0].exampleExtended.errors).to.be.empty;
+    });
+
+    it('ExampleExtendedExtended: should exist without errors', function () {
+        expect(data[0]?.exampleExtendedExtended).to.exist;
+        expect(data[0].exampleExtendedExtended.attributes).to.not.be.empty;
+        expect(data[0].exampleExtendedExtended.errors).to.be.empty;
+    });
+
+    it('ExampleAlias: should exist without errors', function () {
+        expect(data[0]?.exampleAlias).to.exist;
+        expect(data[0].exampleAlias.attributes).to.not.be.empty;
+        expect(data[0].exampleAlias.errors).to.be.empty;
+    });
+
+    it('Example#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('ExampleExtended#a: should be a checkbox attribute', function () {
+        expect(data[0].exampleExtended.attributes.a).to.exist;
+        expect(data[0].exampleExtended.attributes.a.name).to.equal('a');
+        expect(data[0].exampleExtended.attributes.a.type).to.equal('boolean');
+        expect(data[0].exampleExtended.attributes.a.array).to.equal(false);
+        expect(data[0].exampleExtended.attributes.a.default).to.equal(false);
+    });
+
+    it('ExampleExtended#b: should be a numeric attribute', function () {
+        expect(data[0].exampleExtended.attributes.b).to.exist;
+        expect(data[0].exampleExtended.attributes.b.name).to.equal('b');
+        expect(data[0].exampleExtended.attributes.b.type).to.equal('number');
+        expect(data[0].exampleExtended.attributes.b.array).to.equal(false);
+        expect(data[0].exampleExtended.attributes.b.default).to.equal(0);
+    });
+
+    it('ExampleExtendedExtended#a: should be a checkbox attribute', function () {
+        expect(data[0].exampleExtendedExtended.attributes.a).to.exist;
+        expect(data[0].exampleExtendedExtended.attributes.a.name).to.equal('a');
+        expect(data[0].exampleExtendedExtended.attributes.a.type).to.equal('boolean');
+        expect(data[0].exampleExtendedExtended.attributes.a.array).to.equal(false);
+        expect(data[0].exampleExtendedExtended.attributes.a.default).to.equal(false);
+    });
+
+    it('ExampleExtendedExtended#b: should be a numeric attribute', function () {
+        expect(data[0].exampleExtendedExtended.attributes.b).to.exist;
+        expect(data[0].exampleExtendedExtended.attributes.b.name).to.equal('b');
+        expect(data[0].exampleExtendedExtended.attributes.b.type).to.equal('number');
+        expect(data[0].exampleExtendedExtended.attributes.b.array).to.equal(false);
+        expect(data[0].exampleExtendedExtended.attributes.b.default).to.equal(0);
+    });
+
+    it('ExampleExtendedExtended#c: should be a string attribute', function () {
+        expect(data[0].exampleExtendedExtended.attributes.c).to.exist;
+        expect(data[0].exampleExtendedExtended.attributes.c.name).to.equal('c');
+        expect(data[0].exampleExtendedExtended.attributes.c.type).to.equal('string');
+        expect(data[0].exampleExtendedExtended.attributes.c.array).to.equal(false);
+        expect(data[0].exampleExtendedExtended.attributes.c.default).to.equal('');
+    });
+
+    it('ExampleAlias#a: should be a checkbox attribute', function () {
+        expect(data[0].exampleAlias.attributes.a).to.exist;
+        expect(data[0].exampleAlias.attributes.a.name).to.equal('a');
+        expect(data[0].exampleAlias.attributes.a.type).to.equal('boolean');
+        expect(data[0].exampleAlias.attributes.a.array).to.equal(false);
+        expect(data[0].exampleAlias.attributes.a.default).to.equal(false);
+    });
+
+    it('ExampleNoExtend: should not exist (does not extend Script)', function () {
+        expect(data[0].exampleNoExtend).to.not.exist;
+    });
+
+});

package/test/tests/valid/intellisense.test.js

@@ -0,0 +1,36 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it, before } from 'mocha';
+import { expect } from 'chai';
+
+import { getAttributes } from '../../utils.js';
+
+describe('VALID: Intellisense Parsing', function () {
+
+    let data;
+    before(async function () {
+        data = await getAttributes('./intellisense.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', function () {
+        expect(data[0]?.example).to.exist;
+    });
+
+    it('attributes have correct types', function () {
+        expect(data[0].folder[0].type).to.equal('any');
+        expect(data[0].folder[1].type).to.equal('number');
+
+        expect(data[0].example[0].type).to.equal('any');
+        expect(data[0].example[1].type).to.equal('number');
+        expect(data[0].example[2].type).to.equal('boolean');
+        expect(data[0].example[3].type).to.equal('string');
+        expect(data[0].example[4].type).to.equal('{}');
+        expect(data[0].example[5].type).to.equal('Vec3');
+        expect(data[0].example[6].type).to.equal('Folder');
+    });
+});

package/test/tests/valid/json.test.js

@@ -0,0 +1,150 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it, before } from 'mocha';
+import { expect } from 'chai';
+
+import { parseAttributes } from '../../utils.js';
+
+describe('VALID: JSON attribute', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./json.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('f: should be a json attribute', function () {
+        expect(data[0].example.attributes.f).to.exist;
+        expect(data[0].example.attributes.f.name).to.equal('f');
+        expect(data[0].example.attributes.f.type).to.equal('json');
+        expect(data[0].example.attributes.f.array).to.equal(false);
+        expect(data[0].example.attributes.f.default).to.equal(null);
+
+        expect(data[0].example.attributes.f.schema).to.exist;
+    });
+
+    it('f[a]: should be a boolean attribute', function () {
+        expect(data[0].example.attributes.f.schema[0].name).to.equal('a');
+        expect(data[0].example.attributes.f.schema[0].type).to.equal('boolean');
+        expect(data[0].example.attributes.f.schema[0].array).to.equal(false);
+        expect(data[0].example.attributes.f.schema[0].default).to.equal(false);
+    });
+
+    it('f[b]: should be a numeric attribute', function () {
+        expect(data[0].example.attributes.f.schema[1].name).to.equal('b');
+        expect(data[0].example.attributes.f.schema[1].type).to.equal('number');
+        expect(data[0].example.attributes.f.schema[1].array).to.equal(false);
+        expect(data[0].example.attributes.f.schema[1].default).to.equal(10);
+    });
+
+    it('f[c]: should be a string attribute', function () {
+        expect(data[0].example.attributes.f.schema[2].name).to.equal('c');
+        expect(data[0].example.attributes.f.schema[2].type).to.equal('string');
+        expect(data[0].example.attributes.f.schema[2].array).to.equal(false);
+        expect(data[0].example.attributes.f.schema[2].default).to.equal('hello');
+    });
+
+    it('f[d]: should be a vec3 attribute array', function () {
+        expect(data[0].example.attributes.f.schema[3].name).to.equal('d');
+        expect(data[0].example.attributes.f.schema[3].type).to.equal('vec3');
+        expect(data[0].example.attributes.f.schema[3].array).to.equal(true);
+        expect(data[0].example.attributes.f.schema[3].default).to.eql(null);
+    });
+
+    it('g: should be a json attribute array with a 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('json');
+        expect(data[0].example.attributes.g.array).to.equal(true);
+        expect(data[0].example.attributes.g.size).to.equal(2);
+        expect(data[0].example.attributes.g.default).to.eql(null);
+
+        expect(data[0].example.attributes.g.schema).to.exist;
+    });
+
+    it('h: should be a nested json attribute (parent)', function () {
+        expect(data[0].example.attributes.h).to.exist;
+        expect(data[0].example.attributes.h.name).to.equal('h');
+        expect(data[0].example.attributes.h.type).to.equal('json');
+        expect(data[0].example.attributes.h.array).to.equal(false);
+        expect(data[0].example.attributes.h.default).to.eql(null);
+
+        expect(data[0].example.attributes.h.schema).to.exist;
+    });
+
+    it('h[x]: should be a nested json attribute (child)', function () {
+        expect(data[0].example.attributes.h.schema[0].name).to.equal('x');
+        expect(data[0].example.attributes.h.schema[0].type).to.equal('json');
+        expect(data[0].example.attributes.h.schema[0].array).to.equal(false);
+        expect(data[0].example.attributes.h.schema[0].default).to.eql(null);
+
+        expect(data[0].example.attributes.h.schema[0].schema).to.exist;
+    });
+
+    it('i: should be an inline default json attribute', function () {
+        expect(data[0].example.attributes.i).to.exist;
+        expect(data[0].example.attributes.i.name).to.equal('i');
+        expect(data[0].example.attributes.i.type).to.equal('json');
+        expect(data[0].example.attributes.i.array).to.equal(false);
+        expect(data[0].example.attributes.i.default).to.eql(null);
+
+        expect(data[0].example.attributes.i.schema).to.exist;
+    });
+
+    it('j: should be a typedef json attribute', function () {
+        expect(data[0].example.attributes.j).to.exist;
+        expect(data[0].example.attributes.j.name).to.equal('j');
+        expect(data[0].example.attributes.j.type).to.equal('json');
+        expect(data[0].example.attributes.j.array).to.equal(false);
+        expect(data[0].example.attributes.j.default).to.eql(null);
+
+        expect(data[0].example.attributes.j.schema).to.exist;
+    });
+
+    it('k: should be an inline typedef json attribute', function () {
+        expect(data[0].example.attributes.k).to.exist;
+        expect(data[0].example.attributes.k.name).to.equal('k');
+        expect(data[0].example.attributes.k.type).to.equal('json');
+        expect(data[0].example.attributes.k.array).to.equal(false);
+        expect(data[0].example.attributes.k.default).to.eql(null);
+
+        expect(data[0].example.attributes.k.schema).to.exist;
+    });
+
+    it('l: should be an inline type json attribute', function () {
+        expect(data[0].example.attributes.l).to.exist;
+        expect(data[0].example.attributes.l.name).to.equal('l');
+        expect(data[0].example.attributes.l.type).to.equal('json');
+        expect(data[0].example.attributes.l.array).to.equal(false);
+        expect(data[0].example.attributes.l.default).to.eql(null);
+
+        expect(data[0].example.attributes.l.schema).to.exist;
+    });
+
+    it('m: should be a self reference json attribute', function () {
+        expect(data[0].example.attributes.m).to.exist;
+        expect(data[0].example.attributes.m.name).to.equal('m');
+        expect(data[0].example.attributes.m.type).to.equal('json');
+        expect(data[0].example.attributes.m.array).to.equal(false);
+        expect(data[0].example.attributes.m.default).to.eql(null);
+
+        expect(data[0].example.attributes.m.schema).to.exist;
+    });
+
+    it('n: should not be recognised as an attribute (no attribute tag)', function () {
+        expect(data[0].example.attributes.n).to.not.exist;
+    });
+
+    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/valid/misc.test.js

@@ -0,0 +1,47 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it, before } from 'mocha';
+import { expect } from 'chai';
+
+import { parseAttributes } from '../../utils.js';
+
+describe('VALID: Misc attribute types', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./misc.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 numeric attribute with a title and description', 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.title).to.equal('A number');
+        expect(data[0].example.attributes.a.description).to.equal('This is a description of the attribute');
+    });
+
+    it('b: should be a numeric attribute with a getter and setter', 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('number');
+        expect(data[0].example.attributes.b.array).to.equal(false);
+        expect(data[0].example.attributes.b.default).to.equal(0);
+    });
+
+    it('c: should not be recognised as an attribute (no attribute tag)', function () {
+        expect(data[0].example.attributes.c).to.not.exist;
+    });
+
+});

package/test/tests/valid/numeric.test.js

@@ -0,0 +1,104 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it, before } from 'mocha';
+import { expect } from 'chai';
+
+import { parseAttributes } from '../../utils.js';
+
+describe('VALID: Numeric attribute', function () {
+    let data;
+    before(async function () {
+        data = await parseAttributes('./numeric.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 numeric 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('number');
+        expect(data[0].example.attributes.a.array).to.equal(false);
+        expect(data[0].example.attributes.a.default).to.equal(0);
+    });
+
+    it('b: should be a numeric 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('number');
+        expect(data[0].example.attributes.b.array).to.equal(false);
+        expect(data[0].example.attributes.b.default).to.equal(1);
+    });
+
+    it('c: should be a numeric attribute with a precision and step', 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('number');
+        expect(data[0].example.attributes.c.array).to.equal(false);
+        expect(data[0].example.attributes.c.default).to.equal(0);
+        expect(data[0].example.attributes.c.precision).to.equal(2);
+        expect(data[0].example.attributes.c.step).to.equal(0.01);
+    });
+
+    it('d: should be a numeric attribute with a range, precision and step', 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.default).to.equal(0);
+        expect(data[0].example.attributes.d.min).to.equal(0);
+        expect(data[0].example.attributes.d.max).to.equal(1);
+        expect(data[0].example.attributes.d.precision).to.equal(2);
+        expect(data[0].example.attributes.d.step).to.equal(0.01);
+    });
+
+    it('e: should be a numeric attribute array with a size', function () {
+        expect(data[0].example.attributes.e).to.exist;
+        expect(data[0].example.attributes.e.name).to.equal('e');
+        expect(data[0].example.attributes.e.type).to.equal('number');
+        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 numeric attribute in an unusual format', function () {
+        expect(data[0].example.attributes.f).to.exist;
+        expect(data[0].example.attributes.f.name).to.equal('f');
+        expect(data[0].example.attributes.f.type).to.equal('number');
+        expect(data[0].example.attributes.f.array).to.equal(false);
+        expect(data[0].example.attributes.f.default).to.equal(0);
+        expect(data[0].example.attributes.f.min).to.equal(-255);
+        expect(data[0].example.attributes.f.max).to.equal(0);
+        expect(data[0].example.attributes.f.precision).to.equal(2);
+        expect(data[0].example.attributes.f.step).to.equal(0.01);
+    });
+
+    it('g: should be a numeric attribute with single value in range', 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(false);
+        expect(data[0].example.attributes.g.default).to.equal(0);
+        expect(data[0].example.attributes.g.min).to.equal(1);
+        expect(data[0].example.attributes.g.max).to.not.exist;
+    });
+
+    it('h: should be a numeric attribute with empty range', function () {
+        expect(data[0].example.attributes.h).to.exist;
+        expect(data[0].example.attributes.h.name).to.equal('h');
+        expect(data[0].example.attributes.h.type).to.equal('number');
+        expect(data[0].example.attributes.h.array).to.equal(false);
+        expect(data[0].example.attributes.h.default).to.equal(0);
+        expect(data[0].example.attributes.h.min).to.not.exist;
+        expect(data[0].example.attributes.h.max).to.not.exist;
+    });
+
+});

package/test/tests/valid/text.test.js

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