@ibgib/core-gib 0.0.29 → 0.0.30

package/dist/witness/factory/dynamic-form-factory-base.d.mts

@@ -0,0 +1,80 @@
+/**
+ * @module dynamic-form-factory-base
+ *
+ *
+ * @see {@link WitnessFactoryBase}
+ */
+import { TransformResult } from "@ibgib/ts-gib/dist/types.mjs";
+import { IbGib_V1 } from "@ibgib/ts-gib/dist/V1/types.mjs";
+import { DynamicForm, FormItemInfo } from "../../common/form/form-items.mjs";
+import { WitnessFactoryBase } from "./witness-factory-base.mjs";
+import { Witness, WitnessData_V1, WitnessRel8ns_V1 } from "../witness-types.mjs";
+/**
+ * The idea is that any model can be injected via this factory provider.
+ *
+ * So when you create a witness that you want to be able to instantiate via
+ * just metadata, you also provide an accompanying factory that knows
+ * how to map from a
+ *   * witness(model) -> form data (to generate dynamic forms)
+ *   * form data -> witness (to instantiate witness from data)
+ */
+export declare abstract class DynamicFormFactoryBase<TWitnessData extends WitnessData_V1, TWitnessRel8ns extends WitnessRel8ns_V1, TWitness extends Witness<IbGib_V1, IbGib_V1, TWitnessData, TWitnessRel8ns>> extends WitnessFactoryBase<TWitnessData, TWitnessRel8ns, TWitness> {
+    protected lc: string;
+    /**
+     * override this with something that maps from the ibgib/model to the form infos.
+     */
+    abstract witnessToForm({ witness }: {
+        witness: TWitness;
+    }): Promise<DynamicForm>;
+    /**
+     * override this with specific behavior that will reify an instance based on
+     * the given {@link form}.
+     */
+    abstract formToWitness({ form }: {
+        form: DynamicForm;
+    }): Promise<TransformResult<TWitness>>;
+    /**
+     * iterates through the given {@link items}.
+     *
+     * If the item has child items, it is considered a grouping (i.e. FormGroup
+     * or FormArray) and this function is called recursively with the
+     * {@link contextPath} adjusted per the {@link pathDelimiter} and
+     * `item.name`.
+     *
+     * If the item does not have child items, it's considered to be a setting at
+     * the current path level and it's value is assigned per its `item.name` as
+     * the key.
+     */
+    protected patchDataFromItems({ data, contextPath, items, pathDelimiter, }: {
+        /**
+         * ibgib.data object that we are patching/setting from the form items.
+         */
+        data: any;
+        /**
+         * source items whose values we are patching the {@link data} with.
+         */
+        items: FormItemInfo[];
+        /**
+         * Separates sections of pathing into the data object.
+         *
+         * @default @see {@link DEFAULT_DATA_PATH_DELIMITER}
+         */
+        pathDelimiter: string;
+        /**
+         * we're patching the data object as follows:
+         *
+         * data[contextPath/item.name] = value
+         *
+         * where the '/' is the data path delimiter.
+         *
+         * So if the incoming items are nested deeper, this will look like
+         *
+         * data['mysetting/subsetting/color'] = "red"
+         *
+         * @see {@link pathDelimiter}
+         * @see {@link DEFAULT_DATA_PATH_DELIMITER}
+         */
+        contextPath?: string;
+    }): void;
+}
+//# sourceMappingURL=dynamic-form-factory-base.d.mts.map

package/dist/witness/factory/dynamic-form-factory-base.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-form-factory-base.d.mts","sourceRoot":"","sources":["../../../src/witness/factory/dynamic-form-factory-base.mts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAkB,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAE3E,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAC7E,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAKjF;;;;;;;;GAQG;AACH,8BAAsB,sBAAsB,CACxC,YAAY,SAAS,cAAc,EACnC,cAAc,SAAS,gBAAgB,EACvC,QAAQ,SAAS,OAAO,CAAC,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,cAAc,CAAC,CAE1E,SAAQ,kBAAkB,CAAC,YAAY,EAAE,cAAc,EAAE,QAAQ,CAAC;IAClE,SAAS,CAAC,EAAE,EAAE,MAAM,CAAsC;IAC1D;;OAEG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,EAAE,EAAE;QAAE,OAAO,EAAE,QAAQ,CAAA;KAAE,GAAG,OAAO,CAAC,WAAW,CAAC;IAChF;;;OAGG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,WAAW,CAAA;KAAE,GAAG,OAAO,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;IAE3F;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,kBAAkB,CAAC,EACzB,IAAI,EACJ,WAAW,EACX,KAAK,EACL,aAAa,GAChB,EAAE;QACC;;WAEG;QACH,IAAI,EAAE,GAAG,CAAC;QACV;;WAEG;QACH,KAAK,EAAE,YAAY,EAAE,CAAC;QACtB;;;;WAIG;QACH,aAAa,EAAE,MAAM,CAAC;QACtB;;;;;;;;;;;;;WAaG;QACH,WAAW,CAAC,EAAE,MAAM,CAAC;KACxB,GAAG,IAAI;CAwCX"}

package/dist/witness/factory/dynamic-form-factory-base.mjs

@@ -0,0 +1,86 @@
+/**
+ * @module dynamic-form-factory-base
+ *
+ *
+ * @see {@link WitnessFactoryBase}
+ */
+import { patchObject } from "@ibgib/helper-gib/dist/helpers/utils-helper.mjs";
+import { WitnessFactoryBase } from "./witness-factory-base.mjs";
+import { GLOBAL_LOG_A_LOT } from "../../core-constants.mjs";
+const logalot = GLOBAL_LOG_A_LOT || false;
+/**
+ * The idea is that any model can be injected via this factory provider.
+ *
+ * So when you create a witness that you want to be able to instantiate via
+ * just metadata, you also provide an accompanying factory that knows
+ * how to map from a
+ *   * witness(model) -> form data (to generate dynamic forms)
+ *   * form data -> witness (to instantiate witness from data)
+ */
+export class DynamicFormFactoryBase extends WitnessFactoryBase {
+    constructor() {
+        super(...arguments);
+        this.lc = `[${DynamicFormFactoryBase.name}]`;
+    }
+    /**
+     * iterates through the given {@link items}.
+     *
+     * If the item has child items, it is considered a grouping (i.e. FormGroup
+     * or FormArray) and this function is called recursively with the
+     * {@link contextPath} adjusted per the {@link pathDelimiter} and
+     * `item.name`.
+     *
+     * If the item does not have child items, it's considered to be a setting at
+     * the current path level and it's value is assigned per its `item.name` as
+     * the key.
+     */
+    patchDataFromItems({ data, contextPath, items, pathDelimiter, }) {
+        const lc = `${this.lc}[${this.patchDataFromItems.name}]`;
+        try {
+            if (logalot) {
+                console.log(`${lc} starting...`);
+            }
+            if (!pathDelimiter) {
+                throw new Error(`pathDelimiter required (E: 958d472a15fb71e45cd2925883f2ec22)`);
+            }
+            for (let i = 0; i < items.length; i++) {
+                const item = items[i];
+                const path = contextPath ?
+                    contextPath + pathDelimiter + item.name :
+                    item.name;
+                if (!item.items) {
+                    // it's a property (FormControl, not FormGroup/Array)
+                    patchObject({
+                        obj: data,
+                        value: item.value,
+                        path,
+                        logalot,
+                        pathDelimiter,
+                    });
+                }
+                else if (item.items.length > 0) {
+                    // it's a group, so call this function recursively
+                    this.patchDataFromItems({
+                        data,
+                        contextPath: path,
+                        items: item.items,
+                        pathDelimiter,
+                    });
+                }
+                else {
+                    throw new Error(`invalid item. items is truthy but with a length of 0. items should either be falsy or have at least one child. (E: ee2765e0b920477f919fcb09e9d951b4)`);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`${lc} ${error.message}`);
+            throw error;
+        }
+        finally {
+            if (logalot) {
+                console.log(`${lc} complete.`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=dynamic-form-factory-base.mjs.map

package/dist/witness/factory/dynamic-form-factory-base.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-form-factory-base.mjs","sourceRoot":"","sources":["../../../src/witness/factory/dynamic-form-factory-base.mts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,iDAAiD,CAAC;AAK9E,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAGhE,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,MAAM,OAAO,GAAG,gBAAgB,IAAI,KAAK,CAAC;AAE1C;;;;;;;;GAQG;AACH,MAAM,OAAgB,sBAKlB,SAAQ,kBAA0D;IALtE;;QAMc,OAAE,GAAW,IAAI,sBAAsB,CAAC,IAAI,GAAG,CAAC;IAkG9D,CAAC;IAvFG;;;;;;;;;;;OAWG;IACO,kBAAkB,CAAC,EACzB,IAAI,EACJ,WAAW,EACX,KAAK,EACL,aAAa,GA+BhB;QACG,MAAM,EAAE,GAAG,GAAG,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,kBAAkB,CAAC,IAAI,GAAG,CAAC;QACzD,IAAI;YACA,IAAI,OAAO,EAAE;gBAAE,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;aAAE;YAClD,IAAI,CAAC,aAAa,EAAE;gBAAE,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;aAAE;YAExG,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBACnC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;gBACtB,MAAM,IAAI,GAAG,WAAW,CAAC,CAAC;oBACtB,WAAW,GAAG,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;oBACzC,IAAI,CAAC,IAAI,CAAC;gBACd,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE;oBACb,qDAAqD;oBACrD,WAAW,CAAC;wBACR,GAAG,EAAE,IAAI;wBACT,KAAK,EAAE,IAAI,CAAC,KAAK;wBACjB,IAAI;wBACJ,OAAO;wBACP,aAAa;qBAChB,CAAC,CAAC;iBACN;qBAAM,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;oBAC9B,kDAAkD;oBAClD,IAAI,CAAC,kBAAkB,CAAC;wBACpB,IAAI;wBACJ,WAAW,EAAE,IAAI;wBACjB,KAAK,EAAE,IAAI,CAAC,KAAK;wBACjB,aAAa;qBAChB,CAAC,CAAC;iBACN;qBAAM;oBACH,MAAM,IAAI,KAAK,CAAC,sJAAsJ,CAAC,CAAC;iBAC3K;aACJ;SACJ;QAAC,OAAO,KAAK,EAAE;YACZ,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACxC,MAAM,KAAK,CAAC;SACf;gBAAS;YACN,IAAI,OAAO,EAAE;gBAAE,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;aAAE;SACnD;IACL,CAAC;CAEJ"}

package/dist/witness/factory/witness-factory-base.d.mts

@@ -0,0 +1,57 @@
+/**
+ * @module witness-factory-base
+ *
+ * this was a probably-klugy plumbing attempt for ionic-gib to instantiate ibgib
+ * witness objects.
+ *
+ * Specifically this was to go from angular forms to witness ibgibs. The trick
+ * was that ibgib's are data objects and you had to load the witness ibgibs
+ * which actually had functions/methods on them.
+ *
+ * So the workflow was you get a form component with some fields, and you
+ * generate the witness via this factory.
+ *
+ * it worked, but it's not strong I don't think.
+ *
+ * the main weak point is that i didn't fill out the form-items enough and i
+ * never got it so that you could create nested forms.
+ *
+ * in its favor, i do use this (although klugily) in the ibgib rcli app, where
+ * instead of a visual form it prompts the user. terrible ux but it did "work"
+ * as a quick and dirty implementation. it could be polished going forward (i
+ * dont think the design is inherently flawed).
+ */
+import { IbGib_V1 } from "@ibgib/ts-gib/dist/V1/types.mjs";
+import { TransformResult } from "@ibgib/ts-gib/dist/types.mjs";
+import { Witness, WitnessData_V1, WitnessRel8ns_V1 } from "../witness-types.mjs";
+/**
+ * The idea is that any model can be injected via this factory provider.
+ */
+export declare abstract class WitnessFactoryBase<TWitnessData extends WitnessData_V1, TWitnessRel8ns extends WitnessRel8ns_V1, TWitness extends Witness<IbGib_V1, IbGib_V1, TWitnessData, TWitnessRel8ns>> {
+    protected lc: string;
+    /**
+     * override this to provide the name of the class for the factory.
+     *
+     * ## usage
+     *
+     * atm I'm using this to return the classname for the witness.
+     *
+     * @example MyWitnessClass.classname
+     */
+    abstract getName(): string;
+    /**
+     * creates a new witness. This should return the transform result with the
+     * new ibgib being the witness class itself, not just the ibgib dto.
+     *
+     * So said in another way, the `result.newIbGib` should include the class
+     * instantiation which has the `witness` function on it.
+     *
+     * @see {@link WitnessB}
+     */
+    abstract newUp({ data, rel8ns }: {
+        data?: TWitnessData;
+        rel8ns?: TWitnessRel8ns;
+    }): Promise<TransformResult<TWitness>>;
+}
+export type WitnessFactoryAny = WitnessFactoryBase<any, any, any>;
+//# sourceMappingURL=witness-factory-base.d.mts.map

package/dist/witness/factory/witness-factory-base.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"witness-factory-base.d.mts","sourceRoot":"","sources":["../../../src/witness/factory/witness-factory-base.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAkB,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAE/D,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAMjF;;GAEG;AACH,8BAAsB,kBAAkB,CACpC,YAAY,SAAS,cAAc,EACnC,cAAc,SAAS,gBAAgB,EACvC,QAAQ,SAAS,OAAO,CAAC,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,cAAc,CAAC;IAE1E,SAAS,CAAC,EAAE,EAAE,MAAM,CAAkC;IAEtD;;;;;;;;OAQG;IACH,QAAQ,CAAC,OAAO,IAAI,MAAM;IAE1B;;;;;;;;OAQG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE;QAAE,IAAI,CAAC,EAAE,YAAY,CAAC;QAAC,MAAM,CAAC,EAAE,cAAc,CAAA;KAAE,GAC7E,OAAO,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;CAEzC;AAED,MAAM,MAAM,iBAAiB,GAAG,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC"}

package/dist/witness/factory/witness-factory-base.mjs

@@ -0,0 +1,34 @@
+/**
+ * @module witness-factory-base
+ *
+ * this was a probably-klugy plumbing attempt for ionic-gib to instantiate ibgib
+ * witness objects.
+ *
+ * Specifically this was to go from angular forms to witness ibgibs. The trick
+ * was that ibgib's are data objects and you had to load the witness ibgibs
+ * which actually had functions/methods on them.
+ *
+ * So the workflow was you get a form component with some fields, and you
+ * generate the witness via this factory.
+ *
+ * it worked, but it's not strong I don't think.
+ *
+ * the main weak point is that i didn't fill out the form-items enough and i
+ * never got it so that you could create nested forms.
+ *
+ * in its favor, i do use this (although klugily) in the ibgib rcli app, where
+ * instead of a visual form it prompts the user. terrible ux but it did "work"
+ * as a quick and dirty implementation. it could be polished going forward (i
+ * dont think the design is inherently flawed).
+ */
+// import * as c from '../constants';
+// const logalot = c.GLOBAL_LOG_A_LOT || false;
+/**
+ * The idea is that any model can be injected via this factory provider.
+ */
+export class WitnessFactoryBase {
+    constructor() {
+        this.lc = `[${WitnessFactoryBase.name}]`;
+    }
+}
+//# sourceMappingURL=witness-factory-base.mjs.map

package/dist/witness/factory/witness-factory-base.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"witness-factory-base.mjs","sourceRoot":"","sources":["../../../src/witness/factory/witness-factory-base.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAOH,qCAAqC;AAErC,+CAA+C;AAE/C;;GAEG;AACH,MAAM,OAAgB,kBAAkB;IAAxC;QAKc,OAAE,GAAW,IAAI,kBAAkB,CAAC,IAAI,GAAG,CAAC;IAyB1D,CAAC;CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ibgib/core-gib",
-  "version": "0.0.29",
+  "version": "0.0.30",
   "description": "ibgib core functionality, including base architecture for witnesses, spaces, apps, robbots, etc., as well as shared utility functions. Node v19+ needed for heavily-used isomorphic webcrypto hashing consumed in both node and browsers.",
   "repository": {
     "url": "https://gitlab.com/ibgib/core-gib",

package/src/witness/factory/dynamic-form-factory-base.mts

@@ -0,0 +1,132 @@
+/**
+ * @module dynamic-form-factory-base
+ *
+ *
+ * @see {@link WitnessFactoryBase}
+ */
+
+import { patchObject } from "@ibgib/helper-gib/dist/helpers/utils-helper.mjs";
+import { TransformResult } from "@ibgib/ts-gib/dist/types.mjs";
+import { IbGibRel8ns_V1, IbGib_V1 } from "@ibgib/ts-gib/dist/V1/types.mjs";
+
+import { DynamicForm, FormItemInfo } from "../../common/form/form-items.mjs";
+import { WitnessFactoryBase } from "./witness-factory-base.mjs";
+import { Witness, WitnessData_V1, WitnessRel8ns_V1 } from "../witness-types.mjs";
+
+import { GLOBAL_LOG_A_LOT } from "../../core-constants.mjs";
+const logalot = GLOBAL_LOG_A_LOT || false;
+
+/**
+ * The idea is that any model can be injected via this factory provider.
+ *
+ * So when you create a witness that you want to be able to instantiate via
+ * just metadata, you also provide an accompanying factory that knows
+ * how to map from a
+ *   * witness(model) -> form data (to generate dynamic forms)
+ *   * form data -> witness (to instantiate witness from data)
+ */
+export abstract class DynamicFormFactoryBase<
+    TWitnessData extends WitnessData_V1,
+    TWitnessRel8ns extends WitnessRel8ns_V1,
+    TWitness extends Witness<IbGib_V1, IbGib_V1, TWitnessData, TWitnessRel8ns>
+>
+    extends WitnessFactoryBase<TWitnessData, TWitnessRel8ns, TWitness>{
+    protected lc: string = `[${DynamicFormFactoryBase.name}]`;
+    /**
+     * override this with something that maps from the ibgib/model to the form infos.
+     */
+    abstract witnessToForm({ witness }: { witness: TWitness }): Promise<DynamicForm>;
+    /**
+     * override this with specific behavior that will reify an instance based on
+     * the given {@link form}.
+     */
+    abstract formToWitness({ form }: { form: DynamicForm }): Promise<TransformResult<TWitness>>;
+
+    /**
+     * iterates through the given {@link items}.
+     *
+     * If the item has child items, it is considered a grouping (i.e. FormGroup
+     * or FormArray) and this function is called recursively with the
+     * {@link contextPath} adjusted per the {@link pathDelimiter} and
+     * `item.name`.
+     *
+     * If the item does not have child items, it's considered to be a setting at
+     * the current path level and it's value is assigned per its `item.name` as
+     * the key.
+     */
+    protected patchDataFromItems({
+        data,
+        contextPath,
+        items,
+        pathDelimiter,
+    }: {
+        /**
+         * ibgib.data object that we are patching/setting from the form items.
+         */
+        data: any,
+        /**
+         * source items whose values we are patching the {@link data} with.
+         */
+        items: FormItemInfo[],
+        /**
+         * Separates sections of pathing into the data object.
+         *
+         * @default @see {@link DEFAULT_DATA_PATH_DELIMITER}
+         */
+        pathDelimiter: string,
+        /**
+         * we're patching the data object as follows:
+         *
+         * data[contextPath/item.name] = value
+         *
+         * where the '/' is the data path delimiter.
+         *
+         * So if the incoming items are nested deeper, this will look like
+         *
+         * data['mysetting/subsetting/color'] = "red"
+         *
+         * @see {@link pathDelimiter}
+         * @see {@link DEFAULT_DATA_PATH_DELIMITER}
+         */
+        contextPath?: string,
+    }): void {
+        const lc = `${this.lc}[${this.patchDataFromItems.name}]`;
+        try {
+            if (logalot) { console.log(`${lc} starting...`); }
+            if (!pathDelimiter) { throw new Error(`pathDelimiter required (E: 958d472a15fb71e45cd2925883f2ec22)`); }
+
+            for (let i = 0; i < items.length; i++) {
+                const item = items[i];
+                const path = contextPath ?
+                    contextPath + pathDelimiter + item.name :
+                    item.name;
+                if (!item.items) {
+                    // it's a property (FormControl, not FormGroup/Array)
+                    patchObject({
+                        obj: data,
+                        value: item.value,
+                        path,
+                        logalot,
+                        pathDelimiter,
+                    });
+                } else if (item.items.length > 0) {
+                    // it's a group, so call this function recursively
+                    this.patchDataFromItems({
+                        data,
+                        contextPath: path,
+                        items: item.items,
+                        pathDelimiter,
+                    });
+                } else {
+                    throw new Error(`invalid item. items is truthy but with a length of 0. items should either be falsy or have at least one child. (E: ee2765e0b920477f919fcb09e9d951b4)`);
+                }
+            }
+        } catch (error) {
+            console.error(`${lc} ${error.message}`);
+            throw error;
+        } finally {
+            if (logalot) { console.log(`${lc} complete.`); }
+        }
+    }
+
+}

package/src/witness/factory/witness-factory-base.mts

@@ -0,0 +1,69 @@
+/**
+ * @module witness-factory-base
+ *
+ * this was a probably-klugy plumbing attempt for ionic-gib to instantiate ibgib
+ * witness objects.
+ *
+ * Specifically this was to go from angular forms to witness ibgibs. The trick
+ * was that ibgib's are data objects and you had to load the witness ibgibs
+ * which actually had functions/methods on them.
+ *
+ * So the workflow was you get a form component with some fields, and you
+ * generate the witness via this factory.
+ *
+ * it worked, but it's not strong I don't think.
+ *
+ * the main weak point is that i didn't fill out the form-items enough and i
+ * never got it so that you could create nested forms.
+ *
+ * in its favor, i do use this (although klugily) in the ibgib rcli app, where
+ * instead of a visual form it prompts the user. terrible ux but it did "work"
+ * as a quick and dirty implementation. it could be polished going forward (i
+ * dont think the design is inherently flawed).
+ */
+
+import { IbGibRel8ns_V1, IbGib_V1 } from "@ibgib/ts-gib/dist/V1/types.mjs";
+import { TransformResult } from "@ibgib/ts-gib/dist/types.mjs";
+
+import { Witness, WitnessData_V1, WitnessRel8ns_V1 } from "../witness-types.mjs";
+
+// import * as c from '../constants';
+
+// const logalot = c.GLOBAL_LOG_A_LOT || false;
+
+/**
+ * The idea is that any model can be injected via this factory provider.
+ */
+export abstract class WitnessFactoryBase<
+    TWitnessData extends WitnessData_V1,
+    TWitnessRel8ns extends WitnessRel8ns_V1,
+    TWitness extends Witness<IbGib_V1, IbGib_V1, TWitnessData, TWitnessRel8ns>
+> {
+    protected lc: string = `[${WitnessFactoryBase.name}]`;
+
+    /**
+     * override this to provide the name of the class for the factory.
+     *
+     * ## usage
+     *
+     * atm I'm using this to return the classname for the witness.
+     *
+     * @example MyWitnessClass.classname
+     */
+    abstract getName(): string;
+
+    /**
+     * creates a new witness. This should return the transform result with the
+     * new ibgib being the witness class itself, not just the ibgib dto.
+     *
+     * So said in another way, the `result.newIbGib` should include the class
+     * instantiation which has the `witness` function on it.
+     *
+     * @see {@link WitnessB}
+     */
+    abstract newUp({ data, rel8ns }: { data?: TWitnessData, rel8ns?: TWitnessRel8ns }):
+        Promise<TransformResult<TWitness>>;
+
+}
+
+export type WitnessFactoryAny = WitnessFactoryBase<any, any, any>;