@start9labs/start-sdk 0.4.0-beta.5 → 0.4.0-beta.51

package/package/lib/test/inputSpecBuilder.test.js

@@ -7,20 +7,22 @@ const value_1 = require("../../../base/lib/actions/input/builder/value");
 const variants_1 = require("../../../base/lib/actions/input/builder/variants");
 const setupManifest_1 = require("../manifest/setupManifest");
 const StartSdk_1 = require("../StartSdk");
-describe("builder tests", () => {
-    test("text", async () => {
+describe('builder tests', () => {
+    test('text', async () => {
         const bitcoinPropertiesBuilt = await inputSpec_1.InputSpec.of({
-            "peer-tor-address": value_1.Value.text({
-                name: "Peer tor address",
-                description: "The Tor address of the peer interface",
+            'peer-tor-address': value_1.Value.text({
+                name: 'Peer tor address',
+                description: 'The Tor address of the peer interface',
                 required: true,
                 default: null,
             }),
-        }).build({});
+        })
+            .build({})
+            .then((a) => a.spec);
         expect(bitcoinPropertiesBuilt).toMatchObject({
-            "peer-tor-address": {
-                type: "text",
-                description: "The Tor address of the peer interface",
+            'peer-tor-address': {
+                type: 'text',
+                description: 'The Tor address of the peer interface',
                 warning: null,
                 masked: false,
                 placeholder: null,
@@ -28,122 +30,124 @@ describe("builder tests", () => {
                 maxLength: null,
                 patterns: [],
                 disabled: false,
-                inputmode: "text",
-                name: "Peer tor address",
+                inputmode: 'text',
+                name: 'Peer tor address',
                 required: true,
                 default: null,
             },
         });
     });
 });
-describe("values", () => {
-    test("toggle", async () => {
-        const value = value_1.Value.toggle({
-            name: "Testing",
+describe('values', () => {
+    test('toggle', async () => {
+        const value = await value_1.Value.toggle({
+            name: 'Testing',
             description: null,
             warning: null,
             default: false,
-        });
+        }).build({});
         const validator = value.validator;
         validator.unsafeCast(false);
         (0, output_test_1.testOutput)()(null);
     });
-    test("text", async () => {
-        const value = value_1.Value.text({
-            name: "Testing",
+    test('text', async () => {
+        const value = await value_1.Value.text({
+            name: 'Testing',
             required: true,
             default: null,
-        });
+        }).build({});
         const validator = value.validator;
-        const rawIs = await value.build({});
-        validator.unsafeCast("test text");
+        const rawIs = value.spec;
+        validator.unsafeCast('test text');
         expect(() => validator.unsafeCast(null)).toThrowError();
         (0, output_test_1.testOutput)()(null);
     });
-    test("text with default", async () => {
-        const value = value_1.Value.text({
-            name: "Testing",
+    test('text with default', async () => {
+        const value = await value_1.Value.text({
+            name: 'Testing',
             required: true,
-            default: "this is a default value",
-        });
+            default: 'this is a default value',
+        }).build({});
         const validator = value.validator;
-        const rawIs = await value.build({});
-        validator.unsafeCast("test text");
+        const rawIs = value.spec;
+        validator.unsafeCast('test text');
         expect(() => validator.unsafeCast(null)).toThrowError();
         (0, output_test_1.testOutput)()(null);
     });
-    test("optional text", async () => {
-        const value = value_1.Value.text({
-            name: "Testing",
+    test('optional text', async () => {
+        const value = await value_1.Value.text({
+            name: 'Testing',
             required: false,
             default: null,
-        });
+        }).build({});
         const validator = value.validator;
-        const rawIs = await value.build({});
-        validator.unsafeCast("test text");
+        const rawIs = value.spec;
+        validator.unsafeCast('test text');
         validator.unsafeCast(null);
         (0, output_test_1.testOutput)()(null);
     });
-    test("color", async () => {
-        const value = value_1.Value.color({
-            name: "Testing",
+    test('color', async () => {
+        const value = await value_1.Value.color({
+            name: 'Testing',
             required: false,
             default: null,
             description: null,
             warning: null,
-        });
+        }).build({});
         const validator = value.validator;
-        validator.unsafeCast("#000000");
+        validator.unsafeCast('#000000');
         (0, output_test_1.testOutput)()(null);
     });
-    test("datetime", async () => {
-        const value = value_1.Value.datetime({
-            name: "Testing",
+    test('datetime', async () => {
+        const value = await value_1.Value.datetime({
+            name: 'Testing',
             required: true,
             default: null,
             description: null,
             warning: null,
-            inputmode: "date",
+            inputmode: 'date',
             min: null,
             max: null,
-        });
+        }).build({});
         const validator = value.validator;
-        validator.unsafeCast("2021-01-01");
+        validator.unsafeCast('2021-01-01');
         (0, output_test_1.testOutput)()(null);
     });
-    test("optional datetime", async () => {
-        const value = value_1.Value.datetime({
-            name: "Testing",
+    test('optional datetime', async () => {
+        const value = await value_1.Value.datetime({
+            name: 'Testing',
             required: false,
             default: null,
             description: null,
             warning: null,
-            inputmode: "date",
+            inputmode: 'date',
             min: null,
             max: null,
-        });
+        }).build({});
         const validator = value.validator;
-        validator.unsafeCast("2021-01-01");
+        validator.unsafeCast('2021-01-01');
         (0, output_test_1.testOutput)()(null);
     });
-    test("textarea", async () => {
-        const value = value_1.Value.textarea({
-            name: "Testing",
+    test('textarea', async () => {
+        const value = await value_1.Value.textarea({
+            name: 'Testing',
             required: false,
             default: null,
             description: null,
             warning: null,
             minLength: null,
             maxLength: null,
+            minRows: 3,
+            maxRows: 6,
             placeholder: null,
-        });
+        }).build({});
         const validator = value.validator;
-        validator.unsafeCast("test text");
+        validator.unsafeCast('test text');
         (0, output_test_1.testOutput)()(null);
     });
-    test("number", async () => {
-        const value = value_1.Value.number({
-            name: "Testing",
+    test('number', async () => {
+        const value = await value_1.Value.number({
+            name: 'Testing',
             required: true,
             default: null,
             integer: false,
@@ -154,14 +158,14 @@ describe("values", () => {
             step: null,
             units: null,
             placeholder: null,
-        });
+        }).build({});
         const validator = value.validator;
         validator.unsafeCast(2);
         (0, output_test_1.testOutput)()(null);
     });
-    test("optional number", async () => {
-        const value = value_1.Value.number({
-            name: "Testing",
+    test('optional number', async () => {
+        const value = await value_1.Value.number({
+            name: 'Testing',
             required: false,
             default: null,
             integer: false,
@@ -172,216 +176,215 @@ describe("values", () => {
             step: null,
             units: null,
             placeholder: null,
-        });
+        }).build({});
         const validator = value.validator;
         validator.unsafeCast(2);
         (0, output_test_1.testOutput)()(null);
     });
-    test("select", async () => {
-        const value = value_1.Value.select({
-            name: "Testing",
-            default: "a",
+    test('select', async () => {
+        const value = await value_1.Value.select({
+            name: 'Testing',
+            default: 'a',
             values: {
-                a: "A",
-                b: "B",
+                a: 'A',
+                b: 'B',
             },
             description: null,
             warning: null,
-        });
+        }).build({});
         const validator = value.validator;
-        validator.unsafeCast("a");
-        validator.unsafeCast("b");
-        expect(() => validator.unsafeCast("c")).toThrowError();
+        validator.unsafeCast('a');
+        validator.unsafeCast('b');
+        expect(() => validator.unsafeCast('c')).toThrowError();
         (0, output_test_1.testOutput)()(null);
     });
-    test("nullable select", async () => {
-        const value = value_1.Value.select({
-            name: "Testing",
-            default: "a",
+    test('nullable select', async () => {
+        const value = await value_1.Value.select({
+            name: 'Testing',
+            default: 'a',
             values: {
-                a: "A",
-                b: "B",
+                a: 'A',
+                b: 'B',
             },
             description: null,
             warning: null,
-        });
+        }).build({});
         const validator = value.validator;
-        validator.unsafeCast("a");
-        validator.unsafeCast("b");
+        validator.unsafeCast('a');
+        validator.unsafeCast('b');
         (0, output_test_1.testOutput)()(null);
     });
-    test("multiselect", async () => {
-        const value = value_1.Value.multiselect({
-            name: "Testing",
+    test('multiselect', async () => {
+        const value = await value_1.Value.multiselect({
+            name: 'Testing',
             values: {
-                a: "A",
-                b: "B",
+                a: 'A',
+                b: 'B',
             },
             default: [],
             description: null,
             warning: null,
             minLength: null,
             maxLength: null,
-        });
+        }).build({});
         const validator = value.validator;
         validator.unsafeCast([]);
-        validator.unsafeCast(["a", "b"]);
-        expect(() => validator.unsafeCast(["e"])).toThrowError();
+        validator.unsafeCast(['a', 'b']);
+        expect(() => validator.unsafeCast(['e'])).toThrowError();
         expect(() => validator.unsafeCast([4])).toThrowError();
         (0, output_test_1.testOutput)()(null);
     });
-    test("object", async () => {
-        const value = value_1.Value.object({
-            name: "Testing",
+    test('object', async () => {
+        const value = await value_1.Value.object({
+            name: 'Testing',
             description: null,
         }, inputSpec_1.InputSpec.of({
             a: value_1.Value.toggle({
-                name: "test",
+                name: 'test',
                 description: null,
                 warning: null,
                 default: false,
             }),
-        }));
+        })).build({});
         const validator = value.validator;
         validator.unsafeCast({ a: true });
         (0, output_test_1.testOutput)()(null);
     });
-    test("union", async () => {
-        const value = value_1.Value.union({
-            name: "Testing",
-            default: "a",
+    test('union', async () => {
+        const value = await value_1.Value.union({
+            name: 'Testing',
+            default: 'a',
             description: null,
             warning: null,
-        }, variants_1.Variants.of({
-            a: {
-                name: "a",
-                spec: inputSpec_1.InputSpec.of({
-                    b: value_1.Value.toggle({
-                        name: "b",
-                        description: null,
-                        warning: null,
-                        default: false,
+            variants: variants_1.Variants.of({
+                a: {
+                    name: 'a',
+                    spec: inputSpec_1.InputSpec.of({
+                        b: value_1.Value.toggle({
+                            name: 'b',
+                            description: null,
+                            warning: null,
+                            default: false,
+                        }),
                     }),
-                }),
-            },
-        }));
+                },
+            }),
+        }).build({});
         const validator = value.validator;
-        validator.unsafeCast({ selection: "a", value: { b: false } });
+        validator.unsafeCast({ selection: 'a', value: { b: false } });
         (0, output_test_1.testOutput)()(null);
     });
-    describe("dynamic", () => {
+    describe('dynamic', () => {
         const fakeOptions = {
-            inputSpec: "inputSpec",
-            effects: "effects",
-            utils: "utils",
+            inputSpec: 'inputSpec',
+            effects: 'effects',
+            utils: 'utils',
         };
-        test("toggle", async () => {
-            const value = value_1.Value.dynamicToggle(async () => ({
-                name: "Testing",
+        test('toggle', async () => {
+            const value = await value_1.Value.dynamicToggle(async () => ({
+                name: 'Testing',
                 description: null,
                 warning: null,
                 default: false,
-            }));
+            })).build({});
             const validator = value.validator;
             validator.unsafeCast(false);
             expect(() => validator.unsafeCast(null)).toThrowError();
             (0, output_test_1.testOutput)()(null);
-            expect(await value.build(fakeOptions)).toMatchObject({
-                name: "Testing",
+            expect(value.spec).toMatchObject({
+                name: 'Testing',
                 description: null,
                 warning: null,
                 default: false,
             });
         });
-        test("text", async () => {
-            const value = value_1.Value.dynamicText(async () => ({
-                name: "Testing",
+        test('text', async () => {
+            const value = await value_1.Value.dynamicText(async () => ({
+                name: 'Testing',
                 required: false,
                 default: null,
-            }));
+            })).build({});
             const validator = value.validator;
-            const rawIs = await value.build({});
-            validator.unsafeCast("test text");
+            const rawIs = value.spec;
+            validator.unsafeCast('test text');
             validator.unsafeCast(null);
             (0, output_test_1.testOutput)()(null);
-            expect(await value.build(fakeOptions)).toMatchObject({
-                name: "Testing",
+            expect(value.spec).toMatchObject({
+                name: 'Testing',
                 required: false,
                 default: null,
             });
         });
-        test("text with default", async () => {
-            const value = value_1.Value.dynamicText(async () => ({
-                name: "Testing",
+        test('text with default', async () => {
+            const value = await value_1.Value.dynamicText(async () => ({
+                name: 'Testing',
                 required: false,
-                default: "this is a default value",
-            }));
+                default: 'this is a default value',
+            })).build({});
             const validator = value.validator;
-            validator.unsafeCast("test text");
+            validator.unsafeCast('test text');
             validator.unsafeCast(null);
             (0, output_test_1.testOutput)()(null);
-            expect(await value.build(fakeOptions)).toMatchObject({
-                name: "Testing",
+            expect(value.spec).toMatchObject({
+                name: 'Testing',
                 required: false,
-                default: "this is a default value",
+                default: 'this is a default value',
             });
         });
-        test("optional text", async () => {
-            const value = value_1.Value.dynamicText(async () => ({
-                name: "Testing",
+        test('optional text', async () => {
+            const value = await value_1.Value.dynamicText(async () => ({
+                name: 'Testing',
                 required: false,
                 default: null,
-            }));
+            })).build({});
             const validator = value.validator;
-            const rawIs = await value.build({});
-            validator.unsafeCast("test text");
+            const rawIs = value.spec;
+            validator.unsafeCast('test text');
             validator.unsafeCast(null);
             (0, output_test_1.testOutput)()(null);
-            expect(await value.build(fakeOptions)).toMatchObject({
-                name: "Testing",
+            expect(value.spec).toMatchObject({
+                name: 'Testing',
                 required: false,
                 default: null,
             });
         });
-        test("color", async () => {
-            const value = value_1.Value.dynamicColor(async () => ({
-                name: "Testing",
+        test('color', async () => {
+            const value = await value_1.Value.dynamicColor(async () => ({
+                name: 'Testing',
                 required: false,
                 default: null,
                 description: null,
                 warning: null,
-            }));
+            })).build({});
             const validator = value.validator;
-            validator.unsafeCast("#000000");
+            validator.unsafeCast('#000000');
             validator.unsafeCast(null);
             (0, output_test_1.testOutput)()(null);
-            expect(await value.build(fakeOptions)).toMatchObject({
-                name: "Testing",
+            expect(value.spec).toMatchObject({
+                name: 'Testing',
                 required: false,
                 default: null,
                 description: null,
                 warning: null,
             });
         });
-        test("datetime", async () => {
+        test('datetime', async () => {
             const sdk = StartSdk_1.StartSdk.of()
                 .withManifest((0, setupManifest_1.setupManifest)({
-                id: "testOutput",
-                title: "",
-                license: "",
-                wrapperRepo: "",
-                upstreamRepo: "",
-                supportSite: "",
-                marketingSite: "",
+                id: 'testOutput',
+                title: '',
+                license: '',
+                packageRepo: '',
+                upstreamRepo: '',
+                marketingUrl: '',
                 donationUrl: null,
+                docsUrls: [],
                 description: {
-                    short: "",
-                    long: "",
+                    short: '',
+                    long: '',
                 },
-                containers: {},
                 images: {},
                 volumes: [],
-                assets: [],
                 alerts: {
                     install: null,
                     update: null,
@@ -391,66 +394,60 @@ describe("values", () => {
                     stop: null,
                 },
                 dependencies: {
-                    "remote-test": {
-                        description: "",
+                    'remote-test': {
+                        description: '',
                         optional: true,
-                        s9pk: "https://example.com/remote-test.s9pk",
+                        s9pk: 'https://example.com/remote-test.s9pk',
                     },
                 },
             }))
-                .withStore()
                 .build(true);
-            const value = value_1.Value.dynamicDatetime(async ({ effects }) => {
-                ;
-                async () => {
-                    ;
-                    (await sdk.store
-                        .getOwn(effects, sdk.StorePath.test)
-                        .once());
-                };
+            const value = await value_1.Value.dynamicDatetime(async ({ effects }) => {
                 return {
-                    name: "Testing",
-                    required: true,
+                    name: 'Testing',
+                    required: false,
                     default: null,
-                    inputmode: "date",
+                    inputmode: 'date',
                 };
-            });
+            }).build({});
             const validator = value.validator;
-            validator.unsafeCast("2021-01-01");
+            validator.unsafeCast('2021-01-01');
             validator.unsafeCast(null);
             (0, output_test_1.testOutput)()(null);
-            expect(await value.build(fakeOptions)).toMatchObject({
-                name: "Testing",
-                required: true,
+            expect(value.spec).toMatchObject({
+                name: 'Testing',
+                required: false,
                 default: null,
                 description: null,
                 warning: null,
-                inputmode: "date",
+                inputmode: 'date',
             });
         });
-        test("textarea", async () => {
-            const value = value_1.Value.dynamicTextarea(async () => ({
-                name: "Testing",
+        test('textarea', async () => {
+            const value = await value_1.Value.dynamicTextarea(async () => ({
+                name: 'Testing',
                 required: false,
                 default: null,
                 description: null,
                 warning: null,
                 minLength: null,
                 maxLength: null,
+                minRows: 3,
+                maxRows: 6,
                 placeholder: null,
-            }));
+            })).build({});
             const validator = value.validator;
-            validator.unsafeCast("test text");
+            validator.unsafeCast('test text');
             (0, output_test_1.testOutput)()(null);
-            expect(await value.build(fakeOptions)).toMatchObject({
-                name: "Testing",
+            expect(value.spec).toMatchObject({
+                name: 'Testing',
                 required: false,
             });
         });
-        test("number", async () => {
-            const value = value_1.Value.dynamicNumber(() => ({
-                name: "Testing",
-                required: true,
+        test('number', async () => {
+            const value = await value_1.Value.dynamicNumber(() => ({
+                name: 'Testing',
+                required: false,
                 default: null,
                 integer: false,
                 description: null,
@@ -460,246 +457,247 @@ describe("values", () => {
                 step: null,
                 units: null,
                 placeholder: null,
-            }));
+            })).build({});
             const validator = value.validator;
             validator.unsafeCast(2);
             validator.unsafeCast(null);
-            expect(() => validator.unsafeCast("null")).toThrowError();
+            expect(() => validator.unsafeCast('null')).toThrowError();
             (0, output_test_1.testOutput)()(null);
-            expect(await value.build(fakeOptions)).toMatchObject({
-                name: "Testing",
-                required: true,
+            expect(value.spec).toMatchObject({
+                name: 'Testing',
+                required: false,
             });
         });
-        test("select", async () => {
-            const value = value_1.Value.dynamicSelect(() => ({
-                name: "Testing",
-                default: "a",
+        test('select', async () => {
+            const value = await value_1.Value.dynamicSelect(() => ({
+                name: 'Testing',
+                default: 'a',
                 values: {
-                    a: "A",
-                    b: "B",
+                    a: 'A',
+                    b: 'B',
                 },
                 description: null,
                 warning: null,
-            }));
+            })).build({});
             const validator = value.validator;
-            validator.unsafeCast("a");
-            validator.unsafeCast("b");
-            validator.unsafeCast("c");
+            validator.unsafeCast('a');
+            validator.unsafeCast('b');
             (0, output_test_1.testOutput)()(null);
-            expect(await value.build(fakeOptions)).toMatchObject({
-                name: "Testing",
+            expect(value.spec).toMatchObject({
+                name: 'Testing',
             });
         });
-        test("multiselect", async () => {
-            const value = value_1.Value.dynamicMultiselect(() => ({
-                name: "Testing",
+        test('multiselect', async () => {
+            const value = await value_1.Value.dynamicMultiselect(() => ({
+                name: 'Testing',
                 values: {
-                    a: "A",
-                    b: "B",
+                    a: 'A',
+                    b: 'B',
                 },
                 default: [],
                 description: null,
                 warning: null,
                 minLength: null,
                 maxLength: null,
-            }));
+            })).build({});
             const validator = value.validator;
             validator.unsafeCast([]);
-            validator.unsafeCast(["a", "b"]);
-            validator.unsafeCast(["c"]);
+            validator.unsafeCast(['a', 'b']);
             expect(() => validator.unsafeCast([4])).toThrowError();
             expect(() => validator.unsafeCast(null)).toThrowError();
             (0, output_test_1.testOutput)()(null);
-            expect(await value.build(fakeOptions)).toMatchObject({
-                name: "Testing",
+            expect(value.spec).toMatchObject({
+                name: 'Testing',
                 default: [],
             });
         });
     });
-    describe("filtering", () => {
-        test("union", async () => {
-            const value = value_1.Value.filteredUnion(() => ["a", "c"], {
-                name: "Testing",
-                default: "a",
+    describe('filtering', () => {
+        test('union', async () => {
+            const value = await value_1.Value.dynamicUnion(() => ({
+                name: 'Testing',
+                default: 'a',
                 description: null,
                 warning: null,
-            }, variants_1.Variants.of({
-                a: {
-                    name: "a",
-                    spec: inputSpec_1.InputSpec.of({
-                        b: value_1.Value.toggle({
-                            name: "b",
-                            description: null,
-                            warning: null,
-                            default: false,
+                disabled: ['a', 'c'],
+                variants: variants_1.Variants.of({
+                    a: {
+                        name: 'a',
+                        spec: inputSpec_1.InputSpec.of({
+                            b: value_1.Value.toggle({
+                                name: 'b',
+                                description: null,
+                                warning: null,
+                                default: false,
+                            }),
                         }),
-                    }),
-                },
-                b: {
-                    name: "b",
-                    spec: inputSpec_1.InputSpec.of({
-                        b: value_1.Value.toggle({
-                            name: "b",
-                            description: null,
-                            warning: null,
-                            default: false,
+                    },
+                    b: {
+                        name: 'b',
+                        spec: inputSpec_1.InputSpec.of({
+                            b: value_1.Value.toggle({
+                                name: 'b',
+                                description: null,
+                                warning: null,
+                                default: false,
+                            }),
                         }),
-                    }),
-                },
-            }));
+                    },
+                }),
+            })).build({});
             const validator = value.validator;
-            validator.unsafeCast({ selection: "a", value: { b: false } });
+            validator.unsafeCast({ selection: 'a', value: { b: false } });
             (0, output_test_1.testOutput)()(null);
-            const built = await value.build({});
+            const built = value.spec;
             expect(built).toMatchObject({
-                name: "Testing",
+                name: 'Testing',
                 variants: {
                     b: {},
                 },
             });
             expect(built).toMatchObject({
-                name: "Testing",
+                name: 'Testing',
                 variants: {
                     a: {},
                     b: {},
                 },
             });
             expect(built).toMatchObject({
-                name: "Testing",
+                name: 'Testing',
                 variants: {
                     a: {},
                     b: {},
                 },
-                disabled: ["a", "c"],
+                disabled: ['a', 'c'],
             });
         });
     });
-    test("dynamic union", async () => {
-        const value = value_1.Value.dynamicUnion(() => ({
-            disabled: ["a", "c"],
-            name: "Testing",
-            default: "b",
+    test('dynamic union', async () => {
+        const value = await value_1.Value.dynamicUnion(() => ({
+            disabled: ['a', 'c'],
+            name: 'Testing',
+            default: 'b',
             description: null,
             warning: null,
-        }), variants_1.Variants.of({
-            a: {
-                name: "a",
-                spec: inputSpec_1.InputSpec.of({
-                    b: value_1.Value.toggle({
-                        name: "b",
-                        description: null,
-                        warning: null,
-                        default: false,
+            variants: variants_1.Variants.of({
+                a: {
+                    name: 'a',
+                    spec: inputSpec_1.InputSpec.of({
+                        b: value_1.Value.toggle({
+                            name: 'b',
+                            description: null,
+                            warning: null,
+                            default: false,
+                        }),
                     }),
-                }),
-            },
-            b: {
-                name: "b",
-                spec: inputSpec_1.InputSpec.of({
-                    b: value_1.Value.toggle({
-                        name: "b",
-                        description: null,
-                        warning: null,
-                        default: false,
+                },
+                b: {
+                    name: 'b',
+                    spec: inputSpec_1.InputSpec.of({
+                        b: value_1.Value.toggle({
+                            name: 'b',
+                            description: null,
+                            warning: null,
+                            default: false,
+                        }),
                     }),
-                }),
-            },
-        }));
+                },
+            }),
+        })).build({});
         const validator = value.validator;
-        validator.unsafeCast({ selection: "a", value: { b: false } });
+        validator.unsafeCast({ selection: 'a', value: { b: false } });
         (0, output_test_1.testOutput)()(null);
-        const built = await value.build({});
+        const built = value.spec;
         expect(built).toMatchObject({
-            name: "Testing",
+            name: 'Testing',
             variants: {
                 b: {},
             },
         });
         expect(built).toMatchObject({
-            name: "Testing",
+            name: 'Testing',
             variants: {
                 a: {},
                 b: {},
             },
         });
         expect(built).toMatchObject({
-            name: "Testing",
+            name: 'Testing',
             variants: {
                 a: {},
                 b: {},
             },
-            disabled: ["a", "c"],
+            disabled: ['a', 'c'],
         });
     });
 });
-describe("Builder List", () => {
-    test("obj", async () => {
-        const value = value_1.Value.list(list_1.List.obj({
-            name: "test",
+describe('Builder List', () => {
+    test('obj', async () => {
+        const value = await value_1.Value.list(list_1.List.obj({
+            name: 'test',
         }, {
             spec: inputSpec_1.InputSpec.of({
                 test: value_1.Value.toggle({
-                    name: "test",
+                    name: 'test',
                     description: null,
                     warning: null,
                     default: false,
                 }),
             }),
-        }));
+        })).build({});
         const validator = value.validator;
         validator.unsafeCast([{ test: true }]);
         (0, output_test_1.testOutput)()(null);
     });
-    test("text", async () => {
-        const value = value_1.Value.list(list_1.List.text({
-            name: "test",
+    test('text', async () => {
+        const value = await value_1.Value.list(list_1.List.text({
+            name: 'test',
         }, {
             patterns: [],
-        }));
+        })).build({});
         const validator = value.validator;
-        validator.unsafeCast(["test", "text"]);
+        validator.unsafeCast(['test', 'text']);
         (0, output_test_1.testOutput)()(null);
     });
-    describe("dynamic", () => {
-        test("text", async () => {
-            const value = value_1.Value.list(list_1.List.dynamicText(() => ({
-                name: "test",
+    describe('dynamic', () => {
+        test('text', async () => {
+            const value = await value_1.Value.list(list_1.List.dynamicText(() => ({
+                name: 'test',
                 spec: { patterns: [] },
-            })));
+            }))).build({});
             const validator = value.validator;
-            validator.unsafeCast(["test", "text"]);
+            validator.unsafeCast(['test', 'text']);
             expect(() => validator.unsafeCast([3, 4])).toThrowError();
             expect(() => validator.unsafeCast(null)).toThrowError();
             (0, output_test_1.testOutput)()(null);
-            expect(await value.build({})).toMatchObject({
-                name: "test",
+            expect(value.spec).toMatchObject({
+                name: 'test',
                 spec: { patterns: [] },
             });
         });
     });
 });
-describe("Nested nullable values", () => {
-    test("Testing text", async () => {
-        const value = inputSpec_1.InputSpec.of({
+describe('Nested nullable values', () => {
+    test('Testing text', async () => {
+        const value = await inputSpec_1.InputSpec.of({
             a: value_1.Value.text({
-                name: "Temp Name",
-                description: "If no name is provided, the name from inputSpec will be used",
+                name: 'Temp Name',
+                description: 'If no name is provided, the name from inputSpec will be used',
                 required: false,
                 default: null,
             }),
-        });
+        }).build({});
         const validator = value.validator;
         validator.unsafeCast({ a: null });
-        validator.unsafeCast({ a: "test" });
+        validator.unsafeCast({ a: 'test' });
         expect(() => validator.unsafeCast({ a: 4 })).toThrowError();
         (0, output_test_1.testOutput)()(null);
     });
-    test("Testing number", async () => {
-        const value = inputSpec_1.InputSpec.of({
+    test('Testing number', async () => {
+        const value = await inputSpec_1.InputSpec.of({
             a: value_1.Value.number({
-                name: "Temp Name",
-                description: "If no name is provided, the name from inputSpec will be used",
+                name: 'Temp Name',
+                description: 'If no name is provided, the name from inputSpec will be used',
                 required: false,
                 default: null,
                 warning: null,
@@ -710,74 +708,74 @@ describe("Nested nullable values", () => {
                 step: null,
                 units: null,
             }),
-        });
+        }).build({});
         const validator = value.validator;
         validator.unsafeCast({ a: null });
         validator.unsafeCast({ a: 5 });
-        expect(() => validator.unsafeCast({ a: "4" })).toThrowError();
+        expect(() => validator.unsafeCast({ a: '4' })).toThrowError();
         (0, output_test_1.testOutput)()(null);
     });
-    test("Testing color", async () => {
-        const value = inputSpec_1.InputSpec.of({
+    test('Testing color', async () => {
+        const value = await inputSpec_1.InputSpec.of({
             a: value_1.Value.color({
-                name: "Temp Name",
-                description: "If no name is provided, the name from inputSpec will be used",
+                name: 'Temp Name',
+                description: 'If no name is provided, the name from inputSpec will be used',
                 required: false,
                 default: null,
                 warning: null,
             }),
-        });
+        }).build({});
         const validator = value.validator;
         validator.unsafeCast({ a: null });
-        validator.unsafeCast({ a: "5" });
+        validator.unsafeCast({ a: '5' });
         expect(() => validator.unsafeCast({ a: 4 })).toThrowError();
         (0, output_test_1.testOutput)()(null);
     });
-    test("Testing select", async () => {
-        const value = inputSpec_1.InputSpec.of({
+    test('Testing select', async () => {
+        const value = await inputSpec_1.InputSpec.of({
             a: value_1.Value.select({
-                name: "Temp Name",
-                description: "If no name is provided, the name from inputSpec will be used",
-                default: "a",
+                name: 'Temp Name',
+                description: 'If no name is provided, the name from inputSpec will be used',
+                default: 'a',
                 warning: null,
                 values: {
-                    a: "A",
+                    a: 'A',
                 },
             }),
-        });
+        }).build({});
         const higher = await value_1.Value.select({
-            name: "Temp Name",
-            description: "If no name is provided, the name from inputSpec will be used",
-            default: "a",
+            name: 'Temp Name',
+            description: 'If no name is provided, the name from inputSpec will be used',
+            default: 'a',
             warning: null,
             values: {
-                a: "A",
+                a: 'A',
             },
         }).build({});
         const validator = value.validator;
-        validator.unsafeCast({ a: "a" });
-        expect(() => validator.unsafeCast({ a: "4" })).toThrowError();
+        validator.unsafeCast({ a: 'a' });
+        expect(() => validator.unsafeCast({ a: '4' })).toThrowError();
         (0, output_test_1.testOutput)()(null);
     });
-    test("Testing multiselect", async () => {
-        const value = inputSpec_1.InputSpec.of({
+    test('Testing multiselect', async () => {
+        const value = await inputSpec_1.InputSpec.of({
             a: value_1.Value.multiselect({
-                name: "Temp Name",
-                description: "If no name is provided, the name from inputSpec will be used",
+                name: 'Temp Name',
+                description: 'If no name is provided, the name from inputSpec will be used',
                 warning: null,
                 default: [],
                 values: {
-                    a: "A",
+                    a: 'A',
                 },
                 minLength: null,
                 maxLength: null,
             }),
-        });
+        }).build({});
         const validator = value.validator;
         validator.unsafeCast({ a: [] });
-        validator.unsafeCast({ a: ["a"] });
-        expect(() => validator.unsafeCast({ a: ["4"] })).toThrowError();
-        expect(() => validator.unsafeCast({ a: "4" })).toThrowError();
+        validator.unsafeCast({ a: ['a'] });
+        expect(() => validator.unsafeCast({ a: ['4'] })).toThrowError();
+        expect(() => validator.unsafeCast({ a: '4' })).toThrowError();
         (0, output_test_1.testOutput)()(null);
     });
 });