@start9labs/start-sdk 0.3.6-alpha1

package/mjs/lib/config/builder/value.d.ts

@@ -0,0 +1,311 @@
+import { Config, LazyBuild } from "./config";
+import { List } from "./list";
+import { Variants } from "./variants";
+import { FilePath, Pattern, RandomString, ValueSpec, ValueSpecDatetime, ValueSpecText } from "../configTypes";
+import { DefaultString } from "../configTypes";
+import { Parser } from "ts-matches";
+export type RequiredDefault<A> = false | {
+    default: A | null;
+};
+type AsRequired<Type, MaybeRequiredType> = MaybeRequiredType extends {
+    default: unknown;
+} | never ? Type : Type | null | undefined;
+/**
+ * A value is going to be part of the form in the FE of the OS.
+ * Something like a boolean, a string, a number, etc.
+ * in the fe it will ask for the name of value, and use the rest of the value to determine how to render it.
+ * While writing with a value, you will start with `Value.` then let the IDE suggest the rest.
+ * for things like string, the options are going to be in {}.
+ * Keep an eye out for another config builder types as params.
+ * Note, usually this is going to be used in a `Config` {@link Config} builder.
+ ```ts
+const username = Value.string({
+  name: "Username",
+  default: "bitcoin",
+  description: "The username for connecting to Bitcoin over RPC.",
+  warning: null,
+  required: true,
+  masked: true,
+  placeholder: null,
+  pattern: "^[a-zA-Z0-9_]+$",
+  patternDescription: "Must be alphanumeric (can contain underscore).",
+});
+ ```
+ */
+export declare class Value<Type, Store> {
+    build: LazyBuild<Store, ValueSpec>;
+    validator: Parser<unknown, Type>;
+    protected constructor(build: LazyBuild<Store, ValueSpec>, validator: Parser<unknown, Type>);
+    static toggle(a: {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        default: boolean;
+        /**  Immutable means it can only be configed at the first config then never again
+        Default is false */
+        immutable?: boolean;
+    }): Value<boolean, never>;
+    static dynamicToggle<Store = never>(a: LazyBuild<Store, {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        default: boolean;
+        disabled?: false | string;
+    }>): Value<boolean, Store>;
+    static text<Required extends RequiredDefault<DefaultString>>(a: {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        required: Required;
+        /** Default = false */
+        masked?: boolean;
+        placeholder?: string | null;
+        minLength?: number | null;
+        maxLength?: number | null;
+        patterns?: Pattern[];
+        /** Default = 'text' */
+        inputmode?: ValueSpecText["inputmode"];
+        /**  Immutable means it can only be configured at the first config then never again
+         * Default is false
+         */
+        immutable?: boolean;
+        generate?: null | RandomString;
+    }): Value<AsRequired<string, Required>, never>;
+    static dynamicText<Store = never>(getA: LazyBuild<Store, {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        required: RequiredDefault<DefaultString>;
+        /** Default = false */
+        masked?: boolean;
+        placeholder?: string | null;
+        minLength?: number | null;
+        maxLength?: number | null;
+        patterns?: Pattern[];
+        /** Default = 'text' */
+        inputmode?: ValueSpecText["inputmode"];
+        disabled?: string | false;
+        /**  Immutable means it can only be configured at the first config then never again
+         * Default is false
+         */
+        generate?: null | RandomString;
+    }>): Value<string | null | undefined, Store>;
+    static textarea(a: {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        required: boolean;
+        minLength?: number | null;
+        maxLength?: number | null;
+        placeholder?: string | null;
+        /**  Immutable means it can only be configed at the first config then never again
+        Default is false */
+        immutable?: boolean;
+    }): Value<string, never>;
+    static dynamicTextarea<Store = never>(getA: LazyBuild<Store, {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        required: boolean;
+        minLength?: number | null;
+        maxLength?: number | null;
+        placeholder?: string | null;
+        disabled?: false | string;
+    }>): Value<string, Store>;
+    static number<Required extends RequiredDefault<number>>(a: {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        required: Required;
+        min?: number | null;
+        max?: number | null;
+        /** Default = '1' */
+        step?: number | null;
+        integer: boolean;
+        units?: string | null;
+        placeholder?: string | null;
+        /**  Immutable means it can only be configed at the first config then never again
+        Default is false */
+        immutable?: boolean;
+    }): Value<AsRequired<number, Required>, never>;
+    static dynamicNumber<Store = never>(getA: LazyBuild<Store, {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        required: RequiredDefault<number>;
+        min?: number | null;
+        max?: number | null;
+        /** Default = '1' */
+        step?: number | null;
+        integer: boolean;
+        units?: string | null;
+        placeholder?: string | null;
+        disabled?: false | string;
+    }>): Value<number | null | undefined, Store>;
+    static color<Required extends RequiredDefault<string>>(a: {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        required: Required;
+        /**  Immutable means it can only be configed at the first config then never again
+        Default is false */
+        immutable?: boolean;
+    }): Value<AsRequired<string, Required>, never>;
+    static dynamicColor<Store = never>(getA: LazyBuild<Store, {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        required: RequiredDefault<string>;
+        disabled?: false | string;
+    }>): Value<string | null | undefined, Store>;
+    static datetime<Required extends RequiredDefault<string>>(a: {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        required: Required;
+        /** Default = 'datetime-local' */
+        inputmode?: ValueSpecDatetime["inputmode"];
+        min?: string | null;
+        max?: string | null;
+        /**  Immutable means it can only be configed at the first config then never again
+        Default is false */
+        immutable?: boolean;
+    }): Value<AsRequired<string, Required>, never>;
+    static dynamicDatetime<Store = never>(getA: LazyBuild<Store, {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        required: RequiredDefault<string>;
+        /** Default = 'datetime-local' */
+        inputmode?: ValueSpecDatetime["inputmode"];
+        min?: string | null;
+        max?: string | null;
+        disabled?: false | string;
+    }>): Value<string | null | undefined, Store>;
+    static select<Required extends RequiredDefault<string>, B extends Record<string, string>>(a: {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        required: Required;
+        values: B;
+        /**
+         * Disabled:  false means that there is nothing disabled, good to modify
+         *           string means that this is the message displayed and the whole thing is disabled
+         *           string[] means that the options are disabled
+         */
+        disabled?: false | string | (string & keyof B)[];
+        /**  Immutable means it can only be configed at the first config then never again
+        Default is false */
+        immutable?: boolean;
+    }): Value<AsRequired<keyof B, Required>, never>;
+    static dynamicSelect<Store = never>(getA: LazyBuild<Store, {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        required: RequiredDefault<string>;
+        values: Record<string, string>;
+        /**
+         * Disabled:  false means that there is nothing disabled, good to modify
+         *           string means that this is the message displayed and the whole thing is disabled
+         *           string[] means that the options are disabled
+         */
+        disabled?: false | string | string[];
+    }>): Value<string | null | undefined, Store>;
+    static multiselect<Values extends Record<string, string>>(a: {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        default: string[];
+        values: Values;
+        minLength?: number | null;
+        maxLength?: number | null;
+        /**  Immutable means it can only be configed at the first config then never again
+        Default is false */
+        immutable?: boolean;
+        /**
+         * Disabled:  false means that there is nothing disabled, good to modify
+         *           string means that this is the message displayed and the whole thing is disabled
+         *           string[] means that the options are disabled
+         */
+        disabled?: false | string | (string & keyof Values)[];
+    }): Value<(keyof Values)[], never>;
+    static dynamicMultiselect<Store = never>(getA: LazyBuild<Store, {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        default: string[];
+        values: Record<string, string>;
+        minLength?: number | null;
+        maxLength?: number | null;
+        /**
+         * Disabled:  false means that there is nothing disabled, good to modify
+         *           string means that this is the message displayed and the whole thing is disabled
+         *           string[] means that the options are disabled
+         */
+        disabled?: false | string | string[];
+    }>): Value<string[], Store>;
+    static object<Type extends Record<string, any>, Store>(a: {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+    }, spec: Config<Type, Store>): Value<Type, Store>;
+    static file<Required extends RequiredDefault<string>, Store>(a: {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        extensions: string[];
+        required: Required;
+    }): Value<AsRequired<FilePath, Required>, Store>;
+    static dynamicFile<Required extends boolean, Store>(a: LazyBuild<Store, {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        extensions: string[];
+        required: Required;
+    }>): Value<string | null | undefined, Store>;
+    static union<Required extends RequiredDefault<string>, Type, Store>(a: {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        required: Required;
+        /**  Immutable means it can only be configed at the first config then never again
+        Default is false */
+        immutable?: boolean;
+        /**
+         * Disabled:  false means that there is nothing disabled, good to modify
+         *           string means that this is the message displayed and the whole thing is disabled
+         *           string[] means that the options are disabled
+         */
+        disabled?: false | string | string[];
+    }, aVariants: Variants<Type, Store>): Value<AsRequired<Type, Required>, Store>;
+    static filteredUnion<Required extends RequiredDefault<string>, Type extends Record<string, any>, Store = never>(getDisabledFn: LazyBuild<Store, string[] | false | string>, a: {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        required: Required;
+    }, aVariants: Variants<Type, Store> | Variants<Type, never>): Value<AsRequired<Type, Required>, Store>;
+    static dynamicUnion<Required extends RequiredDefault<string>, Type extends Record<string, any>, Store = never>(getA: LazyBuild<Store, {
+        disabled: string[] | false | string;
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        required: Required;
+    }>, aVariants: Variants<Type, Store> | Variants<Type, never>): Value<Type | null | undefined, Store>;
+    static list<Type, Store>(a: List<Type, Store>): Value<Type, Store>;
+    /**
+     * Use this during the times that the input needs a more specific type.
+     * Used in types that the value/ variant/ list/ config is constructed somewhere else.
+    ```ts
+    const a = Config.text({
+      name: "a",
+      required: false,
+    })
+  
+    return Config.of<Store>()({
+      myValue: a.withStore(),
+    })
+    ```
+     */
+    withStore<NewStore extends Store extends never ? any : Store>(): Value<Type, NewStore>;
+}
+export {};

package/mjs/lib/config/builder/value.js

@@ -0,0 +1,371 @@
+import { anyOf, arrayOf, boolean, literal, literals, number, object, string, unknown, } from "ts-matches";
+import { once } from "../../util/once";
+function requiredLikeToAbove(requiredLike) {
+    // prettier-ignore
+    return {
+        required: (typeof requiredLike === 'object' ? true : requiredLike),
+        default: (typeof requiredLike === 'object' ? requiredLike.default : null)
+    };
+}
+const testForAsRequiredParser = once(() => object({ required: object({ default: unknown }) }).test);
+function asRequiredParser(parser, input) {
+    if (testForAsRequiredParser()(input))
+        return parser;
+    return parser.optional();
+}
+/**
+ * A value is going to be part of the form in the FE of the OS.
+ * Something like a boolean, a string, a number, etc.
+ * in the fe it will ask for the name of value, and use the rest of the value to determine how to render it.
+ * While writing with a value, you will start with `Value.` then let the IDE suggest the rest.
+ * for things like string, the options are going to be in {}.
+ * Keep an eye out for another config builder types as params.
+ * Note, usually this is going to be used in a `Config` {@link Config} builder.
+ ```ts
+const username = Value.string({
+  name: "Username",
+  default: "bitcoin",
+  description: "The username for connecting to Bitcoin over RPC.",
+  warning: null,
+  required: true,
+  masked: true,
+  placeholder: null,
+  pattern: "^[a-zA-Z0-9_]+$",
+  patternDescription: "Must be alphanumeric (can contain underscore).",
+});
+ ```
+ */
+export class Value {
+    build;
+    validator;
+    constructor(build, validator) {
+        this.build = build;
+        this.validator = validator;
+    }
+    static toggle(a) {
+        return new Value(async () => ({
+            description: null,
+            warning: null,
+            type: "toggle",
+            disabled: false,
+            immutable: a.immutable ?? false,
+            ...a,
+        }), boolean);
+    }
+    static dynamicToggle(a) {
+        return new Value(async (options) => ({
+            description: null,
+            warning: null,
+            type: "toggle",
+            disabled: false,
+            immutable: false,
+            ...(await a(options)),
+        }), boolean);
+    }
+    static text(a) {
+        return new Value(async () => ({
+            type: "text",
+            description: null,
+            warning: null,
+            masked: false,
+            placeholder: null,
+            minLength: null,
+            maxLength: null,
+            patterns: [],
+            inputmode: "text",
+            disabled: false,
+            immutable: a.immutable ?? false,
+            generate: a.generate ?? null,
+            ...a,
+            ...requiredLikeToAbove(a.required),
+        }), asRequiredParser(string, a));
+    }
+    static dynamicText(getA) {
+        return new Value(async (options) => {
+            const a = await getA(options);
+            return {
+                type: "text",
+                description: null,
+                warning: null,
+                masked: false,
+                placeholder: null,
+                minLength: null,
+                maxLength: null,
+                patterns: [],
+                inputmode: "text",
+                disabled: false,
+                immutable: false,
+                generate: a.generate ?? null,
+                ...a,
+                ...requiredLikeToAbove(a.required),
+            };
+        }, string.optional());
+    }
+    static textarea(a) {
+        return new Value(async () => {
+            const built = {
+                description: null,
+                warning: null,
+                minLength: null,
+                maxLength: null,
+                placeholder: null,
+                type: "textarea",
+                disabled: false,
+                immutable: a.immutable ?? false,
+                ...a,
+            };
+            return built;
+        }, string);
+    }
+    static dynamicTextarea(getA) {
+        return new Value(async (options) => {
+            const a = await getA(options);
+            return {
+                description: null,
+                warning: null,
+                minLength: null,
+                maxLength: null,
+                placeholder: null,
+                type: "textarea",
+                disabled: false,
+                immutable: false,
+                ...a,
+            };
+        }, string);
+    }
+    static number(a) {
+        return new Value(() => ({
+            type: "number",
+            description: null,
+            warning: null,
+            min: null,
+            max: null,
+            step: null,
+            units: null,
+            placeholder: null,
+            disabled: false,
+            immutable: a.immutable ?? false,
+            ...a,
+            ...requiredLikeToAbove(a.required),
+        }), asRequiredParser(number, a));
+    }
+    static dynamicNumber(getA) {
+        return new Value(async (options) => {
+            const a = await getA(options);
+            return {
+                type: "number",
+                description: null,
+                warning: null,
+                min: null,
+                max: null,
+                step: null,
+                units: null,
+                placeholder: null,
+                disabled: false,
+                immutable: false,
+                ...a,
+                ...requiredLikeToAbove(a.required),
+            };
+        }, number.optional());
+    }
+    static color(a) {
+        return new Value(() => ({
+            type: "color",
+            description: null,
+            warning: null,
+            disabled: false,
+            immutable: a.immutable ?? false,
+            ...a,
+            ...requiredLikeToAbove(a.required),
+        }), asRequiredParser(string, a));
+    }
+    static dynamicColor(getA) {
+        return new Value(async (options) => {
+            const a = await getA(options);
+            return {
+                type: "color",
+                description: null,
+                warning: null,
+                disabled: false,
+                immutable: false,
+                ...a,
+                ...requiredLikeToAbove(a.required),
+            };
+        }, string.optional());
+    }
+    static datetime(a) {
+        return new Value(() => ({
+            type: "datetime",
+            description: null,
+            warning: null,
+            inputmode: "datetime-local",
+            min: null,
+            max: null,
+            step: null,
+            disabled: false,
+            immutable: a.immutable ?? false,
+            ...a,
+            ...requiredLikeToAbove(a.required),
+        }), asRequiredParser(string, a));
+    }
+    static dynamicDatetime(getA) {
+        return new Value(async (options) => {
+            const a = await getA(options);
+            return {
+                type: "datetime",
+                description: null,
+                warning: null,
+                inputmode: "datetime-local",
+                min: null,
+                max: null,
+                disabled: false,
+                immutable: false,
+                ...a,
+                ...requiredLikeToAbove(a.required),
+            };
+        }, string.optional());
+    }
+    static select(a) {
+        return new Value(() => ({
+            description: null,
+            warning: null,
+            type: "select",
+            disabled: false,
+            immutable: a.immutable ?? false,
+            ...a,
+            ...requiredLikeToAbove(a.required),
+        }), asRequiredParser(anyOf(...Object.keys(a.values).map((x) => literal(x))), a));
+    }
+    static dynamicSelect(getA) {
+        return new Value(async (options) => {
+            const a = await getA(options);
+            return {
+                description: null,
+                warning: null,
+                type: "select",
+                disabled: false,
+                immutable: false,
+                ...a,
+                ...requiredLikeToAbove(a.required),
+            };
+        }, string.optional());
+    }
+    static multiselect(a) {
+        return new Value(() => ({
+            type: "multiselect",
+            minLength: null,
+            maxLength: null,
+            warning: null,
+            description: null,
+            disabled: false,
+            immutable: a.immutable ?? false,
+            ...a,
+        }), arrayOf(literals(...Object.keys(a.values))));
+    }
+    static dynamicMultiselect(getA) {
+        return new Value(async (options) => {
+            const a = await getA(options);
+            return {
+                type: "multiselect",
+                minLength: null,
+                maxLength: null,
+                warning: null,
+                description: null,
+                disabled: false,
+                immutable: false,
+                ...a,
+            };
+        }, arrayOf(string));
+    }
+    static object(a, spec) {
+        return new Value(async (options) => {
+            const built = await spec.build(options);
+            return {
+                type: "object",
+                description: null,
+                warning: null,
+                ...a,
+                spec: built,
+            };
+        }, spec.validator);
+    }
+    static file(a) {
+        const buildValue = {
+            type: "file",
+            description: null,
+            warning: null,
+            ...a,
+        };
+        return new Value(() => ({
+            ...buildValue,
+            ...requiredLikeToAbove(a.required),
+        }), asRequiredParser(object({ filePath: string }), a));
+    }
+    static dynamicFile(a) {
+        return new Value(async (options) => ({
+            type: "file",
+            description: null,
+            warning: null,
+            ...(await a(options)),
+        }), string.optional());
+    }
+    static union(a, aVariants) {
+        return new Value(async (options) => ({
+            type: "union",
+            description: null,
+            warning: null,
+            disabled: false,
+            ...a,
+            variants: await aVariants.build(options),
+            ...requiredLikeToAbove(a.required),
+            immutable: a.immutable ?? false,
+        }), asRequiredParser(aVariants.validator, a));
+    }
+    static filteredUnion(getDisabledFn, a, aVariants) {
+        return new Value(async (options) => ({
+            type: "union",
+            description: null,
+            warning: null,
+            ...a,
+            variants: await aVariants.build(options),
+            ...requiredLikeToAbove(a.required),
+            disabled: (await getDisabledFn(options)) || false,
+            immutable: false,
+        }), asRequiredParser(aVariants.validator, a));
+    }
+    static dynamicUnion(getA, aVariants) {
+        return new Value(async (options) => {
+            const newValues = await getA(options);
+            return {
+                type: "union",
+                description: null,
+                warning: null,
+                ...newValues,
+                variants: await aVariants.build(options),
+                ...requiredLikeToAbove(newValues.required),
+                immutable: false,
+            };
+        }, aVariants.validator.optional());
+    }
+    static list(a) {
+        return new Value((options) => a.build(options), a.validator);
+    }
+    /**
+     * Use this during the times that the input needs a more specific type.
+     * Used in types that the value/ variant/ list/ config is constructed somewhere else.
+    ```ts
+    const a = Config.text({
+      name: "a",
+      required: false,
+    })
+  
+    return Config.of<Store>()({
+      myValue: a.withStore(),
+    })
+    ```
+     */
+    withStore() {
+        return this;
+    }
+}
+//# sourceMappingURL=value.js.map