@start9labs/start-sdk 0.4.0-beta.47 → 0.4.0-beta.49

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

@@ -7,12 +7,12 @@ 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,
             }),
@@ -20,9 +20,9 @@ describe("builder tests", () => {
             .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,
@@ -30,18 +30,18 @@ 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 () => {
+describe('values', () => {
+    test('toggle', async () => {
         const value = await value_1.Value.toggle({
-            name: "Testing",
+            name: 'Testing',
             description: null,
             warning: null,
             default: false,
@@ -50,87 +50,87 @@ describe("values", () => {
         validator.unsafeCast(false);
         (0, output_test_1.testOutput)()(null);
     });
-    test("text", async () => {
+    test('text', async () => {
         const value = await value_1.Value.text({
-            name: "Testing",
+            name: 'Testing',
             required: true,
             default: null,
         }).build({});
         const validator = value.validator;
         const rawIs = value.spec;
-        validator.unsafeCast("test text");
+        validator.unsafeCast('test text');
         expect(() => validator.unsafeCast(null)).toThrowError();
         (0, output_test_1.testOutput)()(null);
     });
-    test("text with default", async () => {
+    test('text with default', async () => {
         const value = await value_1.Value.text({
-            name: "Testing",
+            name: 'Testing',
             required: true,
-            default: "this is a default value",
+            default: 'this is a default value',
         }).build({});
         const validator = value.validator;
         const rawIs = value.spec;
-        validator.unsafeCast("test text");
+        validator.unsafeCast('test text');
         expect(() => validator.unsafeCast(null)).toThrowError();
         (0, output_test_1.testOutput)()(null);
     });
-    test("optional text", async () => {
+    test('optional text', async () => {
         const value = await value_1.Value.text({
-            name: "Testing",
+            name: 'Testing',
             required: false,
             default: null,
         }).build({});
         const validator = value.validator;
         const rawIs = value.spec;
-        validator.unsafeCast("test text");
+        validator.unsafeCast('test text');
         validator.unsafeCast(null);
         (0, output_test_1.testOutput)()(null);
     });
-    test("color", async () => {
+    test('color', async () => {
         const value = await value_1.Value.color({
-            name: "Testing",
+            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 () => {
+    test('datetime', async () => {
         const value = await value_1.Value.datetime({
-            name: "Testing",
+            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 () => {
+    test('optional datetime', async () => {
         const value = await value_1.Value.datetime({
-            name: "Testing",
+            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 () => {
+    test('textarea', async () => {
         const value = await value_1.Value.textarea({
-            name: "Testing",
+            name: 'Testing',
             required: false,
             default: null,
             description: null,
@@ -142,12 +142,12 @@ describe("values", () => {
             placeholder: null,
         }).build({});
         const validator = value.validator;
-        validator.unsafeCast("test text");
+        validator.unsafeCast('test text');
         (0, output_test_1.testOutput)()(null);
     });
-    test("number", async () => {
+    test('number', async () => {
         const value = await value_1.Value.number({
-            name: "Testing",
+            name: 'Testing',
             required: true,
             default: null,
             integer: false,
@@ -163,9 +163,9 @@ describe("values", () => {
         validator.unsafeCast(2);
         (0, output_test_1.testOutput)()(null);
     });
-    test("optional number", async () => {
+    test('optional number', async () => {
         const value = await value_1.Value.number({
-            name: "Testing",
+            name: 'Testing',
             required: false,
             default: null,
             integer: false,
@@ -181,45 +181,45 @@ describe("values", () => {
         validator.unsafeCast(2);
         (0, output_test_1.testOutput)()(null);
     });
-    test("select", async () => {
+    test('select', async () => {
         const value = await value_1.Value.select({
-            name: "Testing",
-            default: "a",
+            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 () => {
+    test('nullable select', async () => {
         const value = await value_1.Value.select({
-            name: "Testing",
-            default: "a",
+            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 () => {
+    test('multiselect', async () => {
         const value = await value_1.Value.multiselect({
-            name: "Testing",
+            name: 'Testing',
             values: {
-                a: "A",
-                b: "B",
+                a: 'A',
+                b: 'B',
             },
             default: [],
             description: null,
@@ -229,18 +229,18 @@ describe("values", () => {
         }).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 () => {
+    test('object', async () => {
         const value = await value_1.Value.object({
-            name: "Testing",
+            name: 'Testing',
             description: null,
         }, inputSpec_1.InputSpec.of({
             a: value_1.Value.toggle({
-                name: "test",
+                name: 'test',
                 description: null,
                 warning: null,
                 default: false,
@@ -250,18 +250,18 @@ describe("values", () => {
         validator.unsafeCast({ a: true });
         (0, output_test_1.testOutput)()(null);
     });
-    test("union", async () => {
+    test('union', async () => {
         const value = await value_1.Value.union({
-            name: "Testing",
-            default: "a",
+            name: 'Testing',
+            default: 'a',
             description: null,
             warning: null,
             variants: variants_1.Variants.of({
                 a: {
-                    name: "a",
+                    name: 'a',
                     spec: inputSpec_1.InputSpec.of({
                         b: value_1.Value.toggle({
-                            name: "b",
+                            name: 'b',
                             description: null,
                             warning: null,
                             default: false,
@@ -271,18 +271,18 @@ describe("values", () => {
             }),
         }).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 () => {
+        test('toggle', async () => {
             const value = await value_1.Value.dynamicToggle(async () => ({
-                name: "Testing",
+                name: 'Testing',
                 description: null,
                 warning: null,
                 default: false,
@@ -292,97 +292,96 @@ describe("values", () => {
             expect(() => validator.unsafeCast(null)).toThrowError();
             (0, output_test_1.testOutput)()(null);
             expect(value.spec).toMatchObject({
-                name: "Testing",
+                name: 'Testing',
                 description: null,
                 warning: null,
                 default: false,
             });
         });
-        test("text", async () => {
+        test('text', async () => {
             const value = await value_1.Value.dynamicText(async () => ({
-                name: "Testing",
+                name: 'Testing',
                 required: false,
                 default: null,
             })).build({});
             const validator = value.validator;
             const rawIs = value.spec;
-            validator.unsafeCast("test text");
+            validator.unsafeCast('test text');
             validator.unsafeCast(null);
             (0, output_test_1.testOutput)()(null);
             expect(value.spec).toMatchObject({
-                name: "Testing",
+                name: 'Testing',
                 required: false,
                 default: null,
             });
         });
-        test("text with default", async () => {
+        test('text with default', async () => {
             const value = await value_1.Value.dynamicText(async () => ({
-                name: "Testing",
+                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(value.spec).toMatchObject({
-                name: "Testing",
+                name: 'Testing',
                 required: false,
-                default: "this is a default value",
+                default: 'this is a default value',
             });
         });
-        test("optional text", async () => {
+        test('optional text', async () => {
             const value = await value_1.Value.dynamicText(async () => ({
-                name: "Testing",
+                name: 'Testing',
                 required: false,
                 default: null,
             })).build({});
             const validator = value.validator;
             const rawIs = value.spec;
-            validator.unsafeCast("test text");
+            validator.unsafeCast('test text');
             validator.unsafeCast(null);
             (0, output_test_1.testOutput)()(null);
             expect(value.spec).toMatchObject({
-                name: "Testing",
+                name: 'Testing',
                 required: false,
                 default: null,
             });
         });
-        test("color", async () => {
+        test('color', async () => {
             const value = await value_1.Value.dynamicColor(async () => ({
-                name: "Testing",
+                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(value.spec).toMatchObject({
-                name: "Testing",
+                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,
-                docsUrl: "",
+                docsUrls: [],
                 description: {
-                    short: "",
-                    long: "",
+                    short: '',
+                    long: '',
                 },
                 images: {},
                 volumes: [],
@@ -395,38 +394,38 @@ 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',
                     },
                 },
             }))
                 .build(true);
             const value = await value_1.Value.dynamicDatetime(async ({ effects }) => {
                 return {
-                    name: "Testing",
+                    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(value.spec).toMatchObject({
-                name: "Testing",
+                name: 'Testing',
                 required: false,
                 default: null,
                 description: null,
                 warning: null,
-                inputmode: "date",
+                inputmode: 'date',
             });
         });
-        test("textarea", async () => {
+        test('textarea', async () => {
             const value = await value_1.Value.dynamicTextarea(async () => ({
-                name: "Testing",
+                name: 'Testing',
                 required: false,
                 default: null,
                 description: null,
@@ -438,16 +437,16 @@ describe("values", () => {
                 placeholder: null,
             })).build({});
             const validator = value.validator;
-            validator.unsafeCast("test text");
+            validator.unsafeCast('test text');
             (0, output_test_1.testOutput)()(null);
             expect(value.spec).toMatchObject({
-                name: "Testing",
+                name: 'Testing',
                 required: false,
             });
         });
-        test("number", async () => {
+        test('number', async () => {
             const value = await value_1.Value.dynamicNumber(() => ({
-                name: "Testing",
+                name: 'Testing',
                 required: false,
                 default: null,
                 integer: false,
@@ -462,38 +461,38 @@ describe("values", () => {
             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(value.spec).toMatchObject({
-                name: "Testing",
+                name: 'Testing',
                 required: false,
             });
         });
-        test("select", async () => {
+        test('select', async () => {
             const value = await value_1.Value.dynamicSelect(() => ({
-                name: "Testing",
-                default: "a",
+                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);
             expect(value.spec).toMatchObject({
-                name: "Testing",
+                name: 'Testing',
             });
         });
-        test("multiselect", async () => {
+        test('multiselect', async () => {
             const value = await value_1.Value.dynamicMultiselect(() => ({
-                name: "Testing",
+                name: 'Testing',
                 values: {
-                    a: "A",
-                    b: "B",
+                    a: 'A',
+                    b: 'B',
                 },
                 default: [],
                 description: null,
@@ -503,30 +502,30 @@ describe("values", () => {
             })).build({});
             const validator = value.validator;
             validator.unsafeCast([]);
-            validator.unsafeCast(["a", "b"]);
+            validator.unsafeCast(['a', 'b']);
             expect(() => validator.unsafeCast([4])).toThrowError();
             expect(() => validator.unsafeCast(null)).toThrowError();
             (0, output_test_1.testOutput)()(null);
             expect(value.spec).toMatchObject({
-                name: "Testing",
+                name: 'Testing',
                 default: [],
             });
         });
     });
-    describe("filtering", () => {
-        test("union", async () => {
+    describe('filtering', () => {
+        test('union', async () => {
             const value = await value_1.Value.dynamicUnion(() => ({
-                name: "Testing",
-                default: "a",
+                name: 'Testing',
+                default: 'a',
                 description: null,
                 warning: null,
-                disabled: ["a", "c"],
+                disabled: ['a', 'c'],
                 variants: variants_1.Variants.of({
                     a: {
-                        name: "a",
+                        name: 'a',
                         spec: inputSpec_1.InputSpec.of({
                             b: value_1.Value.toggle({
-                                name: "b",
+                                name: 'b',
                                 description: null,
                                 warning: null,
                                 default: false,
@@ -534,10 +533,10 @@ describe("values", () => {
                         }),
                     },
                     b: {
-                        name: "b",
+                        name: 'b',
                         spec: inputSpec_1.InputSpec.of({
                             b: value_1.Value.toggle({
-                                name: "b",
+                                name: 'b',
                                 description: null,
                                 warning: null,
                                 default: false,
@@ -547,45 +546,45 @@ describe("values", () => {
                 }),
             })).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 = 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 () => {
+    test('dynamic union', async () => {
         const value = await value_1.Value.dynamicUnion(() => ({
-            disabled: ["a", "c"],
-            name: "Testing",
-            default: "b",
+            disabled: ['a', 'c'],
+            name: 'Testing',
+            default: 'b',
             description: null,
             warning: null,
             variants: variants_1.Variants.of({
                 a: {
-                    name: "a",
+                    name: 'a',
                     spec: inputSpec_1.InputSpec.of({
                         b: value_1.Value.toggle({
-                            name: "b",
+                            name: 'b',
                             description: null,
                             warning: null,
                             default: false,
@@ -593,10 +592,10 @@ describe("values", () => {
                     }),
                 },
                 b: {
-                    name: "b",
+                    name: 'b',
                     spec: inputSpec_1.InputSpec.of({
                         b: value_1.Value.toggle({
-                            name: "b",
+                            name: 'b',
                             description: null,
                             warning: null,
                             default: false,
@@ -606,40 +605,40 @@ describe("values", () => {
             }),
         })).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 = 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 () => {
+describe('Builder List', () => {
+    test('obj', async () => {
         const value = await value_1.Value.list(list_1.List.obj({
-            name: "test",
+            name: 'test',
         }, {
             spec: inputSpec_1.InputSpec.of({
                 test: value_1.Value.toggle({
-                    name: "test",
+                    name: 'test',
                     description: null,
                     warning: null,
                     default: false,
@@ -650,55 +649,55 @@ describe("Builder List", () => {
         validator.unsafeCast([{ test: true }]);
         (0, output_test_1.testOutput)()(null);
     });
-    test("text", async () => {
+    test('text', async () => {
         const value = await value_1.Value.list(list_1.List.text({
-            name: "test",
+            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 () => {
+    describe('dynamic', () => {
+        test('text', async () => {
             const value = await value_1.Value.list(list_1.List.dynamicText(() => ({
-                name: "test",
+                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(value.spec).toMatchObject({
-                name: "test",
+                name: 'test',
                 spec: { patterns: [] },
             });
         });
     });
 });
-describe("Nested nullable values", () => {
-    test("Testing text", async () => {
+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 () => {
+    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,
@@ -713,14 +712,14 @@ describe("Nested nullable values", () => {
         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 () => {
+    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,
@@ -728,45 +727,45 @@ describe("Nested nullable values", () => {
         }).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 () => {
+    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 () => {
+    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,
@@ -774,9 +773,9 @@ describe("Nested nullable values", () => {
         }).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);
     });
 });