@start9labs/start-sdk 0.3.6-alpha8 → 0.3.6-beta.0

package/base/lib/Effects.d.ts

@@ -0,0 +1,172 @@
+import { ActionId, ActionInput, ActionMetadata, SetMainStatus, DependencyRequirement, CheckDependenciesResult, SetHealth, BindParams, HostId, LanInfo, Host, ExportServiceInterfaceParams, ServiceInterface, RequestActionParams, MainStatus } from "./osBindings";
+import { StorePath } from "./util/PathBuilder";
+import { PackageId, Dependencies, ServiceInterfaceId, SmtpValue, ActionResult } from "./types";
+import { UrlString } from "./util/getServiceInterface";
+/** Used to reach out from the pure js runtime */
+export type Effects = {
+    constRetry: () => void;
+    clearCallbacks: (options: {
+        only: number[];
+    } | {
+        except: number[];
+    }) => Promise<null>;
+    action: {
+        /** Define an action that can be invoked by a user or service */
+        export(options: {
+            id: ActionId;
+            metadata: ActionMetadata;
+        }): Promise<null>;
+        /** Remove all exported actions */
+        clear(options: {
+            except: ActionId[];
+        }): Promise<null>;
+        getInput(options: {
+            packageId?: PackageId;
+            actionId: ActionId;
+        }): Promise<ActionInput | null>;
+        run<Input extends Record<string, unknown>>(options: {
+            packageId?: PackageId;
+            actionId: ActionId;
+            input?: Input;
+        }): Promise<ActionResult | null>;
+        request<Input extends Record<string, unknown>>(options: RequestActionParams): Promise<null>;
+        clearRequests(options: {
+            only: string[];
+        } | {
+            except: string[];
+        }): Promise<null>;
+    };
+    /** restart this service's main function */
+    restart(): Promise<null>;
+    /** stop this service's main function */
+    shutdown(): Promise<null>;
+    /** ask the host os what the service's current status is */
+    getStatus(options: {
+        packageId?: PackageId;
+        callback?: () => void;
+    }): Promise<MainStatus>;
+    /** indicate to the host os what runstate the service is in */
+    setMainStatus(options: SetMainStatus): Promise<null>;
+    /** Set the dependencies of what the service needs, usually run during the inputSpec action as a best practice */
+    setDependencies(options: {
+        dependencies: Dependencies;
+    }): Promise<null>;
+    /** Get the list of the dependencies, both the dynamic set by the effect of setDependencies and the end result any required in the manifest  */
+    getDependencies(): Promise<DependencyRequirement[]>;
+    /** Test whether current dependency requirements are satisfied */
+    checkDependencies(options: {
+        packageIds?: PackageId[];
+    }): Promise<CheckDependenciesResult[]>;
+    /** mount a volume of a dependency */
+    mount(options: {
+        location: string;
+        target: {
+            packageId: string;
+            volumeId: string;
+            subpath: string | null;
+            readonly: boolean;
+        };
+    }): Promise<string>;
+    /** Returns a list of the ids of all installed packages */
+    getInstalledPackages(): Promise<string[]>;
+    /** grants access to certain paths in the store to dependents */
+    exposeForDependents(options: {
+        paths: string[];
+    }): Promise<null>;
+    /** sets the result of a health check */
+    setHealth(o: SetHealth): Promise<null>;
+    subcontainer: {
+        /** A low level api used by SubContainer */
+        createFs(options: {
+            imageId: string;
+            name: string | null;
+        }): Promise<[string, string]>;
+        /** A low level api used by SubContainer */
+        destroyFs(options: {
+            guid: string;
+        }): Promise<null>;
+    };
+    /** Creates a host connected to the specified port with the provided options */
+    bind(options: BindParams): Promise<null>;
+    /** Get the port address for a service */
+    getServicePortForward(options: {
+        packageId?: PackageId;
+        hostId: HostId;
+        internalPort: number;
+    }): Promise<LanInfo>;
+    /** Removes all network bindings, called in the setupInputSpec */
+    clearBindings(options: {
+        except: {
+            id: HostId;
+            internalPort: number;
+        }[];
+    }): Promise<null>;
+    /** Returns information about the specified host, if it exists */
+    getHostInfo(options: {
+        packageId?: PackageId;
+        hostId: HostId;
+        callback?: () => void;
+    }): Promise<Host | null>;
+    /** Returns the primary url that a user has selected for a host, if it exists */
+    getPrimaryUrl(options: {
+        packageId?: PackageId;
+        hostId: HostId;
+        callback?: () => void;
+    }): Promise<UrlString | null>;
+    /** Returns the IP address of the container */
+    getContainerIp(): Promise<string>;
+    /** Creates an interface bound to a specific host and port to show to the user */
+    exportServiceInterface(options: ExportServiceInterfaceParams): Promise<null>;
+    /** Returns an exported service interface */
+    getServiceInterface(options: {
+        packageId?: PackageId;
+        serviceInterfaceId: ServiceInterfaceId;
+        callback?: () => void;
+    }): Promise<ServiceInterface | null>;
+    /** Returns all exported service interfaces for a package */
+    listServiceInterfaces(options: {
+        packageId?: PackageId;
+        callback?: () => void;
+    }): Promise<Record<ServiceInterfaceId, ServiceInterface>>;
+    /** Removes all service interfaces */
+    clearServiceInterfaces(options: {
+        except: ServiceInterfaceId[];
+    }): Promise<null>;
+    /** Returns a PEM encoded fullchain for the hostnames specified */
+    getSslCertificate: (options: {
+        hostnames: string[];
+        algorithm?: "ecdsa" | "ed25519";
+        callback?: () => void;
+    }) => Promise<[string, string, string]>;
+    /** Returns a PEM encoded private key corresponding to the certificate for the hostnames specified */
+    getSslKey: (options: {
+        hostnames: string[];
+        algorithm?: "ecdsa" | "ed25519";
+    }) => Promise<string>;
+    store: {
+        /** Get a value in a json like data, can be observed and subscribed */
+        get<Store = never, ExtractStore = unknown>(options: {
+            /** If there is no packageId it is assumed the current package */
+            packageId?: string;
+            /** The path defaults to root level, using the [JsonPath](https://jsonpath.com/) */
+            path: StorePath;
+            callback?: () => void;
+        }): Promise<ExtractStore>;
+        /** Used to store values that can be accessed and subscribed to */
+        set<Store = never, ExtractStore = unknown>(options: {
+            /** Sets the value for the wrapper at the path, it will override, using the [JsonPath](https://jsonpath.com/)  */
+            path: StorePath;
+            value: ExtractStore;
+        }): Promise<null>;
+    };
+    /** sets the version that this service's data has been migrated to */
+    setDataVersion(options: {
+        version: string;
+    }): Promise<null>;
+    /** returns the version that this service's data has been migrated to */
+    getDataVersion(): Promise<string | null>;
+    /** Returns globally configured SMTP settings, if they exist */
+    getSystemSmtp(options: {
+        callback?: () => void;
+    }): Promise<SmtpValue | null>;
+};

package/base/lib/Effects.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Effects.js.map

package/base/lib/Effects.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Effects.js","sourceRoot":"","sources":["../../../base/lib/Effects.ts"],"names":[],"mappings":""}

package/base/lib/actions/index.d.ts

@@ -0,0 +1,41 @@
+import * as T from "../types";
+import * as IST from "../actions/input/inputSpecTypes";
+import { Action } from "./setupActions";
+import { ExtractInputSpecType } from "./input/builder/inputSpec";
+export type RunActionInput<Input> = Input | ((prev?: {
+    spec: IST.InputSpec;
+    value: Input | null;
+}) => Input);
+export declare const runAction: <Input extends Record<string, unknown>>(options: {
+    effects: T.Effects;
+    actionId: T.ActionId;
+    input?: RunActionInput<Input> | undefined;
+}) => Promise<T.ActionResult | null>;
+type GetActionInputType<A extends Action<T.ActionId, any, any>> = A extends Action<T.ActionId, any, infer I> ? ExtractInputSpecType<I> : never;
+type ActionRequestBase = {
+    reason?: string;
+    replayId?: string;
+};
+type ActionRequestInput<T extends Action<T.ActionId, any, any>> = {
+    kind: "partial";
+    value: Partial<GetActionInputType<T>>;
+};
+export type ActionRequestOptions<T extends Action<T.ActionId, any, any>> = ActionRequestBase & ({
+    when?: Exclude<T.ActionRequestTrigger, {
+        condition: "input-not-matches";
+    }>;
+    input?: ActionRequestInput<T>;
+} | {
+    when: T.ActionRequestTrigger & {
+        condition: "input-not-matches";
+    };
+    input: ActionRequestInput<T>;
+});
+export declare const requestAction: <T extends Action<string, any, any>>(options: {
+    effects: T.Effects;
+    packageId: string;
+    action: T;
+    severity: T.ActionSeverity;
+    options?: ActionRequestOptions<T> | undefined;
+}) => Promise<null>;
+export {};

package/base/lib/actions/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestAction = exports.runAction = void 0;
+const runAction = async (options) => {
+    if (options.input) {
+        if (options.input instanceof Function) {
+            const prev = await options.effects.action.getInput({
+                // packageId: options.packageId,
+                actionId: options.actionId,
+            });
+            const input = options.input(prev
+                ? { spec: prev.spec, value: prev.value }
+                : undefined);
+            return options.effects.action.run({
+                // packageId: options.packageId,
+                actionId: options.actionId,
+                input,
+            });
+        }
+        else {
+            return options.effects.action.run({
+                // packageId: options.packageId,
+                actionId: options.actionId,
+                input: options.input,
+            });
+        }
+    }
+    else {
+        return options.effects.action.run({
+            //   packageId: options.packageId,
+            actionId: options.actionId,
+        });
+    }
+};
+exports.runAction = runAction;
+const _validate = {};
+const requestAction = (options) => {
+    const request = options.options || {};
+    const actionId = options.action.id;
+    const req = {
+        ...request,
+        actionId,
+        packageId: options.packageId,
+        action: undefined,
+        severity: options.severity,
+        replayId: request.replayId || `${options.packageId}:${actionId}`,
+    };
+    delete req.action;
+    return options.effects.action.request(req);
+};
+exports.requestAction = requestAction;
+//# sourceMappingURL=index.js.map

package/base/lib/actions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../base/lib/actions/index.ts"],"names":[],"mappings":";;;AASO,MAAM,SAAS,GAAG,KAAK,EAE5B,OAKD,EAAE,EAAE;IACH,IAAI,OAAO,CAAC,KAAK,EAAE;QACjB,IAAI,OAAO,CAAC,KAAK,YAAY,QAAQ,EAAE;YACrC,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC;gBACjD,gCAAgC;gBAChC,QAAQ,EAAE,OAAO,CAAC,QAAQ;aAC3B,CAAC,CAAA;YACF,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CACzB,IAAI;gBACF,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAqB,EAAE,KAAK,EAAE,IAAI,CAAC,KAAc,EAAE;gBAClE,CAAC,CAAC,SAAS,CACd,CAAA;YACD,OAAO,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC;gBAChC,gCAAgC;gBAChC,QAAQ,EAAE,OAAO,CAAC,QAAQ;gBAC1B,KAAK;aACN,CAAC,CAAA;SACH;aAAM;YACL,OAAO,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC;gBAChC,gCAAgC;gBAChC,QAAQ,EAAE,OAAO,CAAC,QAAQ;gBAC1B,KAAK,EAAE,OAAO,CAAC,KAAK;aACrB,CAAC,CAAA;SACH;KACF;SAAM;QACL,OAAO,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC;YAChC,kCAAkC;YAClC,QAAQ,EAAE,OAAO,CAAC,QAAQ;SAC3B,CAAC,CAAA;KACH;AACH,CAAC,CAAA;AArCY,QAAA,SAAS,aAqCrB;AA4BD,MAAM,SAAS,GAAoB,EAIlC,CAAA;AAEM,MAAM,aAAa,GAAG,CAAyC,OAMrE,EAAE,EAAE;IACH,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,EAAE,CAAA;IACrC,MAAM,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,CAAA;IAClC,MAAM,GAAG,GAAG;QACV,GAAG,OAAO;QACV,QAAQ;QACR,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,MAAM,EAAE,SAAS;QACjB,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,QAAQ,EAAE,OAAO,CAAC,QAAQ,IAAI,GAAG,OAAO,CAAC,SAAS,IAAI,QAAQ,EAAE;KACjE,CAAA;IACD,OAAO,GAAG,CAAC,MAAM,CAAA;IACjB,OAAO,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;AAC5C,CAAC,CAAA;AAnBY,QAAA,aAAa,iBAmBzB"}

package/base/lib/actions/input/builder/index.d.ts

@@ -0,0 +1,5 @@
+import { InputSpec } from "./inputSpec";
+import { List } from "./list";
+import { Value } from "./value";
+import { Variants } from "./variants";
+export { InputSpec as InputSpec, List, Value, Variants };

package/base/lib/actions/input/builder/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Variants = exports.Value = exports.List = exports.InputSpec = void 0;
+const inputSpec_1 = require("./inputSpec");
+Object.defineProperty(exports, "InputSpec", { enumerable: true, get: function () { return inputSpec_1.InputSpec; } });
+const list_1 = require("./list");
+Object.defineProperty(exports, "List", { enumerable: true, get: function () { return list_1.List; } });
+const value_1 = require("./value");
+Object.defineProperty(exports, "Value", { enumerable: true, get: function () { return value_1.Value; } });
+const variants_1 = require("./variants");
+Object.defineProperty(exports, "Variants", { enumerable: true, get: function () { return variants_1.Variants; } });
+//# sourceMappingURL=index.js.map

package/base/lib/actions/input/builder/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../base/lib/actions/input/builder/index.ts"],"names":[],"mappings":";;;AAAA,2CAAuC;AAKjB,0FALb,qBAAS,OAKa;AAJ/B,iCAA6B;AAII,qFAJxB,WAAI,OAIwB;AAHrC,mCAA+B;AAGQ,sFAH9B,aAAK,OAG8B;AAF5C,yCAAqC;AAES,yFAFrC,mBAAQ,OAEqC"}

package/base/lib/actions/input/builder/inputSpec.d.ts

@@ -0,0 +1,95 @@
+import { ValueSpec } from "../inputSpecTypes";
+import { Value } from "./value";
+import { Effects } from "../../../Effects";
+import { Parser } from "ts-matches";
+import { DeepPartial } from "../../../types";
+export type LazyBuildOptions<Store> = {
+    effects: Effects;
+};
+export type LazyBuild<Store, ExpectedOut> = (options: LazyBuildOptions<Store>) => Promise<ExpectedOut> | ExpectedOut;
+export type ExtractInputSpecType<A extends Record<string, any> | InputSpec<Record<string, any>, any> | InputSpec<Record<string, any>, never>> = A extends InputSpec<infer B, any> | InputSpec<infer B, never> ? B : A;
+export type ExtractPartialInputSpecType<A extends Record<string, any> | InputSpec<Record<string, any>, any> | InputSpec<Record<string, any>, never>> = A extends InputSpec<infer B, any> | InputSpec<infer B, never> ? DeepPartial<B> : DeepPartial<A>;
+export type InputSpecOf<A extends Record<string, any>, Store = never> = {
+    [K in keyof A]: Value<A[K], Store>;
+};
+export type MaybeLazyValues<A> = LazyBuild<any, A> | A;
+/**
+ * InputSpecs are the specs that are used by the os input specification form for this service.
+ * Here is an example of a simple input specification
+  ```ts
+    const smallInputSpec = InputSpec.of({
+      test: Value.boolean({
+        name: "Test",
+        description: "This is the description for the test",
+        warning: null,
+        default: false,
+      }),
+    });
+  ```
+
+  The idea of an inputSpec is that now the form is going to ask for
+  Test: [ ] and the value is going to be checked as a boolean.
+  There are more complex values like selects, lists, and objects. See {@link Value}
+
+  Also, there is the ability to get a validator/parser from this inputSpec spec.
+  ```ts
+  const matchSmallInputSpec = smallInputSpec.validator();
+  type SmallInputSpec = typeof matchSmallInputSpec._TYPE;
+  ```
+
+  Here is an example of a more complex input specification which came from an input specification for a service
+  that works with bitcoin, like c-lightning.
+  ```ts
+
+    export const hostname = Value.string({
+  name: "Hostname",
+  default: null,
+  description: "Domain or IP address of bitcoin peer",
+  warning: null,
+  required: true,
+  masked: false,
+  placeholder: null,
+  pattern:
+    "(^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$)|((^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$)|(^[a-z2-7]{16}\\.onion$)|(^([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$))",
+  patternDescription:
+    "Must be either a domain name, or an IPv4 or IPv6 address. Do not include protocol scheme (eg 'http://') or port.",
+});
+export const port = Value.number({
+  name: "Port",
+  default: null,
+  description: "Port that peer is listening on for inbound p2p connections",
+  warning: null,
+  required: false,
+  range: "[0,65535]",
+  integral: true,
+  units: null,
+  placeholder: null,
+});
+export const addNodesSpec = InputSpec.of({ hostname: hostname, port: port });
+
+  ```
+ */
+export declare class InputSpec<Type extends Record<string, any>, Store = never> {
+    private readonly spec;
+    validator: Parser<unknown, Type>;
+    private constructor();
+    _TYPE: Type;
+    _PARTIAL: DeepPartial<Type>;
+    build(options: LazyBuildOptions<Store>): Promise<{ [K in keyof Type]: ValueSpec; }>;
+    static of<Spec extends Record<string, Value<any, Store> | Value<any, never>>, Store = never>(spec: Spec): InputSpec<{ [K in keyof Spec]: Spec[K] extends Value<infer T, Store> | Value<infer T, never> ? T : never; }, Store>;
+    /**
+     * Use this during the times that the input needs a more specific type.
+     * Used in types that the value/ variant/ list/ inputSpec is constructed somewhere else.
+    ```ts
+    const a = InputSpec.text({
+      name: "a",
+      required: false,
+    })
+  
+    return InputSpec.of<Store>()({
+      myValue: a.withStore(),
+    })
+    ```
+     */
+    withStore<NewStore extends Store extends never ? any : Store>(): InputSpec<Type, NewStore>;
+}

package/base/lib/actions/input/builder/inputSpec.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputSpec = void 0;
+const ts_matches_1 = require("ts-matches");
+/**
+ * InputSpecs are the specs that are used by the os input specification form for this service.
+ * Here is an example of a simple input specification
+  ```ts
+    const smallInputSpec = InputSpec.of({
+      test: Value.boolean({
+        name: "Test",
+        description: "This is the description for the test",
+        warning: null,
+        default: false,
+      }),
+    });
+  ```
+
+  The idea of an inputSpec is that now the form is going to ask for
+  Test: [ ] and the value is going to be checked as a boolean.
+  There are more complex values like selects, lists, and objects. See {@link Value}
+
+  Also, there is the ability to get a validator/parser from this inputSpec spec.
+  ```ts
+  const matchSmallInputSpec = smallInputSpec.validator();
+  type SmallInputSpec = typeof matchSmallInputSpec._TYPE;
+  ```
+
+  Here is an example of a more complex input specification which came from an input specification for a service
+  that works with bitcoin, like c-lightning.
+  ```ts
+
+    export const hostname = Value.string({
+  name: "Hostname",
+  default: null,
+  description: "Domain or IP address of bitcoin peer",
+  warning: null,
+  required: true,
+  masked: false,
+  placeholder: null,
+  pattern:
+    "(^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$)|((^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$)|(^[a-z2-7]{16}\\.onion$)|(^([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$))",
+  patternDescription:
+    "Must be either a domain name, or an IPv4 or IPv6 address. Do not include protocol scheme (eg 'http://') or port.",
+});
+export const port = Value.number({
+  name: "Port",
+  default: null,
+  description: "Port that peer is listening on for inbound p2p connections",
+  warning: null,
+  required: false,
+  range: "[0,65535]",
+  integral: true,
+  units: null,
+  placeholder: null,
+});
+export const addNodesSpec = InputSpec.of({ hostname: hostname, port: port });
+
+  ```
+ */
+class InputSpec {
+    constructor(spec, validator) {
+        this.spec = spec;
+        this.validator = validator;
+        this._TYPE = null;
+        this._PARTIAL = null;
+    }
+    async build(options) {
+        const answer = {};
+        for (const k in this.spec) {
+            answer[k] = await this.spec[k].build(options);
+        }
+        return answer;
+    }
+    static of(spec) {
+        const validatorObj = {};
+        for (const key in spec) {
+            validatorObj[key] = spec[key].validator;
+        }
+        const validator = (0, ts_matches_1.object)(validatorObj);
+        return new InputSpec(spec, validator);
+    }
+    /**
+     * Use this during the times that the input needs a more specific type.
+     * Used in types that the value/ variant/ list/ inputSpec is constructed somewhere else.
+    ```ts
+    const a = InputSpec.text({
+      name: "a",
+      required: false,
+    })
+  
+    return InputSpec.of<Store>()({
+      myValue: a.withStore(),
+    })
+    ```
+     */
+    withStore() {
+        return this;
+    }
+}
+exports.InputSpec = InputSpec;
+//# sourceMappingURL=inputSpec.js.map

package/base/lib/actions/input/builder/inputSpec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputSpec.js","sourceRoot":"","sources":["../../../../../../base/lib/actions/input/builder/inputSpec.ts"],"names":[],"mappings":";;;AAIA,2CAA2C;AA6B3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,MAAa,SAAS;IACpB,YACmB,IAEhB,EACM,SAAgC;QAHtB,SAAI,GAAJ,IAAI,CAEpB;QACM,cAAS,GAAT,SAAS,CAAuB;QAEzC,UAAK,GAAS,IAAmB,CAAA;QACjC,aAAQ,GAAsB,IAAgC,CAAA;IAF3D,CAAC;IAGJ,KAAK,CAAC,KAAK,CAAC,OAAgC;QAC1C,MAAM,MAAM,GAAG,EAEd,CAAA;QACD,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,IAAI,EAAE;YACzB,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAc,CAAC,CAAA;SACrD;QACD,OAAO,MAAM,CAAA;IACf,CAAC;IAED,MAAM,CAAC,EAAE,CAGP,IAAU;QACV,MAAM,YAAY,GAAG,EAEpB,CAAA;QACD,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;YACtB,YAAY,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,SAAS,CAAA;SACxC;QACD,MAAM,SAAS,GAAG,IAAA,mBAAM,EAAC,YAAY,CAAC,CAAA;QACtC,OAAO,IAAI,SAAS,CASlB,IAAI,EAAE,SAAgB,CAAC,CAAA;IAC3B,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,SAAS;QACP,OAAO,IAAwC,CAAA;IACjD,CAAC;CACF;AA3DD,8BA2DC"}

package/base/lib/actions/input/builder/list.d.ts

@@ -0,0 +1,93 @@
+import { InputSpec, LazyBuild } from "./inputSpec";
+import { ListValueSpecText, Pattern, RandomString, UniqueBy, ValueSpecList } from "../inputSpecTypes";
+import { Parser } from "ts-matches";
+export declare class List<Type, Store> {
+    build: LazyBuild<Store, ValueSpecList>;
+    validator: Parser<unknown, Type>;
+    private constructor();
+    static text(a: {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        default?: string[];
+        minLength?: number | null;
+        maxLength?: number | null;
+    }, aSpec: {
+        /**
+         * @description Mask (aka camouflage) text input with dots: ● ● ●
+         * @default false
+         */
+        masked?: boolean;
+        placeholder?: string | null;
+        minLength?: number | null;
+        maxLength?: number | null;
+        /**
+         * @description A list of regular expressions to which the text must conform to pass validation. A human readable description is provided in case the validation fails.
+         * @default []
+         * @example
+         * ```
+          [
+            {
+              regex: "[a-z]",
+              description: "May only contain lower case letters from the English alphabet."
+            }
+          ]
+         * ```
+         */
+        patterns?: Pattern[];
+        /**
+         * @description Informs the browser how to behave and which keyboard to display on mobile
+         * @default "text"
+         */
+        inputmode?: ListValueSpecText["inputmode"];
+        /**
+         * @description Displays a button that will generate a random string according to the provided charset and len attributes.
+         */
+        generate?: null | RandomString;
+    }): List<string[], never>;
+    static dynamicText<Store = never>(getA: LazyBuild<Store, {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        default?: string[];
+        minLength?: number | null;
+        maxLength?: number | null;
+        disabled?: false | string;
+        generate?: null | RandomString;
+        spec: {
+            masked?: boolean;
+            placeholder?: string | null;
+            minLength?: number | null;
+            maxLength?: number | null;
+            patterns?: Pattern[];
+            inputmode?: ListValueSpecText["inputmode"];
+        };
+    }>): List<string[], Store>;
+    static obj<Type extends Record<string, any>, Store>(a: {
+        name: string;
+        description?: string | null;
+        warning?: string | null;
+        default?: [];
+        minLength?: number | null;
+        maxLength?: number | null;
+    }, aSpec: {
+        spec: InputSpec<Type, Store>;
+        displayAs?: null | string;
+        uniqueBy?: null | UniqueBy;
+    }): List<Type[], Store>;
+    /**
+     * Use this during the times that the input needs a more specific type.
+     * Used in types that the value/ variant/ list/ inputSpec is constructed somewhere else.
+    ```ts
+    const a = InputSpec.text({
+      name: "a",
+      required: false,
+    })
+  
+    return InputSpec.of<Store>()({
+      myValue: a.withStore(),
+    })
+    ```
+     */
+    withStore<NewStore extends Store extends never ? any : Store>(): List<Type, NewStore>;
+}