@ibgib/ts-gib 0.4.9

package/src/V1/factory.mts

@@ -0,0 +1,110 @@
+import { fork } from './transforms/fork.mjs';
+import { mut8 } from './transforms/mut8.mjs';
+import { rel8 } from './transforms/rel8.mjs';
+import { Ib, IbGib, IbGibRel8ns, TransformResult, TemporalJunctionPointOptions } from '../types.mjs';
+import { IbGib_V1 } from './types.mjs';
+import { IB, GIB, ROOT } from './constants.mjs';
+
+export class Factory_V1 {
+    static root() {
+        return Factory_V1.primitive({ ib: IB });
+    }
+    static primitive({
+        ib
+    }: {
+        ib: Ib
+    }): IbGib_V1 {
+        return { ib, gib: GIB };
+    }
+
+    static primitives({
+        ibs
+    }: {
+        ibs: Ib[]
+    }) {
+        return ibs.map(ib => Factory_V1.primitive({ ib }));
+    }
+
+    static async firstGen<TData = any>({
+        ib = IB,
+        parentIbGib = Factory_V1.root(),
+        data,
+        rel8ns,
+        dna,
+        tjp,
+        linkedRel8ns,
+        noTimestamp,
+        nCounter,
+    }: {
+        ib: Ib,
+        parentIbGib: IbGib,
+        data?: TData,
+        rel8ns?: IbGibRel8ns,
+        dna?: boolean,
+        tjp?: TemporalJunctionPointOptions;
+        linkedRel8ns?: string[],
+        noTimestamp?: boolean,
+        nCounter?: boolean,
+    }) {
+        const lc = `[firstGen]`;
+        /** * Multiple transform steps will create multiple results. */
+        const interimResults: TransformResult<IbGib_V1>[] = [];
+        let src: IbGib_V1 = parentIbGib || ROOT;
+        let resFork = await fork({
+            src,
+            destIb: ib,
+            tjp,
+            dna,
+            linkedRel8ns,
+            noTimestamp,
+            nCounter,
+        });
+        interimResults.push(resFork);
+        src = resFork.newIbGib;
+
+        if (data) {
+            let resMut8 = await mut8({
+                src,
+                dataToAddOrPatch: data,
+                dna,
+                linkedRel8ns,
+                noTimestamp,
+                nCounter,
+            });
+            interimResults.push(resMut8);
+            src = resMut8.newIbGib;
+        };
+
+        if (rel8ns) {
+            let resRel8 = await rel8({
+                src,
+                rel8nsToAddByAddr: rel8ns,
+                dna,
+                linkedRel8ns,
+                noTimestamp,
+                nCounter,
+            });
+            interimResults.push(resRel8);
+            // src = resRel8.newIbGib; // not needed because not used (this is the last step)
+        }
+
+        if (interimResults.length > 1) {
+            const newIbGib = interimResults.slice(interimResults.length - 1)[0].newIbGib;
+            const result = {
+                newIbGib,
+                intermediateIbGibs: interimResults.slice(0, interimResults.length - 1).map(x => x.newIbGib),
+            } as TransformResult<IbGib_V1>;
+            if (dna) {
+                let dnas: IbGib_V1[] = [];
+                interimResults.forEach(res => { dnas = dnas.concat(res.dnas!); });
+                result.dnas = dnas;
+            }
+            return result;
+        } else if (interimResults.length === 1) {
+            // for some reason the caller just used this as a fork.
+            return interimResults[0];
+        } else {
+            throw new Error(`${lc} hmm, I'm not sure...`);
+        }
+    }
+}

package/src/V1/factory.spec.mts

@@ -0,0 +1,162 @@
+
+import { IbGib_V1, IbGibRel8ns_V1, Rel8n } from './types.mjs';
+import { fork } from './transforms/fork.mjs';
+import { TransformOpts_Fork, IbGibAddr, Ib, TransformResult, IbGibRel8ns } from '../types.mjs';
+import { pretty, clone, delay, getIbGibAddr } from '../helper.mjs';
+import { ROOT, ROOT_ADDR } from './constants.mjs';
+import { Factory_V1 as factory } from './factory.mjs';
+import { mut8 } from './transforms/mut8.mjs';
+import { sha256v1 } from './sha256v1.mjs';
+import { getGib, getGibInfo } from './transforms/transform-helper.mjs';
+
+const PRIMITIVE_IBS: string[] = [
+    'a', '7', 'tag',
+    'any string/value that isnt hashed with a gib is a primitive',
+    // e.g. 6 -> 6^ -> 6^gib are all equivalent ib^gib addresses,
+];
+
+
+const DATA_SIMPLE_XY = { x: 1, y: 2 };
+
+const SIMPLE_REL8N_NAMES: string[] = [
+    // just some possible example rel8n names
+    'child', 'container', 'folder', 'identity', 'tag', 'liked'
+];
+
+
+describe(`when using factory`, () => {
+
+    it(`primitives() should make multiple ibgibs`, async () => {
+        const primitiveIbGibs = factory.primitives({ ibs: PRIMITIVE_IBS });
+        expect(primitiveIbGibs).toBeTruthy();
+        expect(primitiveIbGibs.length).toEqual(PRIMITIVE_IBS.length);
+    });
+
+    describe(`firstGen`, () => {
+        it(`should make an ibgib`, async () => {
+            const testIb = 'some ib here';
+            const { newIbGib } = await factory.firstGen({
+                ib: testIb,
+                parentIbGib: ROOT,
+            });
+            expect(newIbGib).toBeTruthy;
+        });
+        it(`should make ibgibs with initial data`, async () => {
+            const testIb = 'some ib here';
+            const { newIbGib, intermediateIbGibs } = await factory.firstGen({
+                ib: testIb,
+                parentIbGib: ROOT,
+                data: DATA_SIMPLE_XY,
+                noTimestamp: true,
+            });
+            expect(newIbGib.data).withContext(`newIbGib.data`).toBeTruthy();
+            expect(newIbGib.data).toEqual(DATA_SIMPLE_XY);
+
+            // an intermediate ibGib should be created with
+            // the same ib, but not yet mutated with the data.
+            expect(intermediateIbGibs).withContext(`intermediateIbGibs`).toBeTruthy();
+            expect(intermediateIbGibs!.length).toEqual(1);
+            expect(intermediateIbGibs![0].ib).toEqual(testIb);
+            expect(intermediateIbGibs![0].data).withContext(`intermediateIbGibs[0].data`).not.toBeTruthy();
+        });
+        it(`should make ibgibs with initial data & rel8ns`, async () => {
+            const primitiveIbgibAddrs =
+                factory
+                    .primitives({ ibs: PRIMITIVE_IBS })
+                    .map(ibGib => getIbGibAddr({ ibGib }));
+
+            const testRel8ns: IbGibRel8ns = {};
+            SIMPLE_REL8N_NAMES.forEach(rel8nName => {
+                testRel8ns[rel8nName] = primitiveIbgibAddrs;
+            });
+            const testIb = 'some ib here';
+            const { newIbGib, intermediateIbGibs } = await factory.firstGen({
+                ib: testIb,
+                parentIbGib: ROOT,
+                data: DATA_SIMPLE_XY,
+                noTimestamp: true,
+                rel8ns: testRel8ns,
+            });
+            expect(newIbGib.data).withContext(`newIbGib.data`).toBeTruthy();
+            expect(newIbGib.data).toEqual(DATA_SIMPLE_XY);
+            expect(newIbGib.rel8ns).withContext(`newIbGib.rel8ns`).toBeTruthy();
+            SIMPLE_REL8N_NAMES.forEach(rel8nName => {
+                expect(newIbGib.rel8ns![rel8nName]).toEqual(primitiveIbgibAddrs);
+            })
+
+            // an intermediate ibGib should be created with
+            // the same ib, but not yet mutated with the data.
+            expect(intermediateIbGibs).withContext(`intermediateIbGibs`).toBeTruthy();
+            expect(intermediateIbGibs!.length).toEqual(2);
+            expect(intermediateIbGibs![0].ib).toEqual(testIb);
+            expect(intermediateIbGibs![1].ib).toEqual(testIb);
+        });
+
+
+
+    });
+
+    describe('other stuff here because jasmine is opinionated about no async in describe', () => {
+        var allIbGibs: IbGib_V1[];
+        beforeAll(async () => {
+            // I'm having some weird discrepancies between calling `sha256v1` and
+            // `getGib` (which itself calls sha256v1 supposedly).
+            //
+            // SOLUTION: these "weird" discrepancies were major bugs...how in the
+            // world it's been going this long, I don't know. Good God...
+            // anyway, I was calculating the gib in the fork and rel8 transforms
+            // before adding the dna to the rel8ns. I have no idea how I didn't catch
+            // this earlier!
+            let badIbGib: IbGib_V1 = {
+                "ib": "comment ff1at755",
+                "gib": "CA4B24EE80C62A781379B263BCBF1F6C68DDA53D67C9195213635A8C08CDBA45",
+                "rel8ns": {
+                    "ancestor": [
+                        "comment^gib"
+                    ],
+                    "dna": [
+                        "fork^846B2C9498D4AE906D235DFCFA31C8E71089A93AF1950849F67430468FF36B92"
+                    ]
+                },
+                "data": {
+                    "n": 0,
+                    "timestamp": "Fri, 18 Feb 2022 13:56:01 GMT",
+                    "uuid": "c4773e052dedc808dcc932d371e724bc4d47410d6833b95b8bd0e403adb6f4b3",
+                    "isTjp": true
+                }
+            };
+
+            const text = "ff1 at 755";
+            const data: any = { text, textTimestamp: "Fri, 18 Feb 2022 13:56:01 GMT" };
+
+            // create an ibgib with the filename and ext
+            const opts: any = {
+                parentIbGib: factory.primitive({ ib: 'comment' }),
+                ib: badIbGib.ib,
+                data,
+                dna: true,
+                tjp: { uuid: true, timestamp: true },
+                nCounter: true,
+            };
+
+            const resCommentIbGib = await factory.firstGen(opts);
+            allIbGibs = [
+                resCommentIbGib!.newIbGib,
+                ...resCommentIbGib.intermediateIbGibs!,
+                ...resCommentIbGib.dnas!
+            ];
+        });
+
+        it('should match up ibGib.gib and getGib & should match up sha256v1 hash and punctiliar hash', async () => {
+            for (let i = 0; i < allIbGibs.length; i++) {
+                const x = allIbGibs[i];
+                let hash_sha256v1Direct = await sha256v1(x, '');
+                let hash_getGib = await getGib({ ibGib: x });
+                let punctiliarHash = getGibInfo({ gib: hash_getGib }).punctiliarHash;
+                expect(hash_getGib).toEqual(x.gib!, 'hash_getGib does not equal x.gib');
+                expect(hash_sha256v1Direct).toEqual(punctiliarHash!);
+            }
+        });
+    });
+
+});

package/src/V1/index.mts

@@ -0,0 +1,5 @@
+export * from './sha256v1.mjs';
+export * from './factory.mjs';
+export * from './types.mjs';
+export * from './constants.mjs';
+export * from './transforms/index.mjs';

package/src/V1/sha256v1.mts

@@ -0,0 +1,85 @@
+let crypto: any = globalThis.crypto;
+let { subtle } = crypto;
+
+import { IbGib_V1, IbGibData_V1, IbGibRel8ns_V1 } from "./types.mjs";
+import { Ib } from "../types.mjs";
+import { extractErrorMsg } from "../helper.mjs";
+
+/**
+ * Performs the gib hash like V1
+ *
+ * I have it all in one function for smallest, most independent version possible.
+ *
+ * #thanks https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest
+ *
+ * @param ibGib ibGib for which to calculate the gib
+ */
+export function sha256v1(ibGib: IbGib_V1, salt: string = ""): Promise<string> {
+    // console.log('func_gib_sha256v1 executed');
+    if (!salt) { salt = ""; }
+    let hashToHex = async (message: string | undefined) => {
+        if (!message) { return ""; }
+        const msgUint8 = new TextEncoder().encode(message);
+        const buffer = await subtle.digest('SHA-256', msgUint8);
+        const asArray = Array.from(new Uint8Array(buffer));
+        return asArray.map(b => b.toString(16).padStart(2, '0')).join('');
+    };
+    let hashFields;
+    if (salt) {
+        hashFields = async (ib: Ib, data: IbGibData_V1 | undefined, rel8ns: IbGibRel8ns_V1 | undefined) => {
+            const hasRel8ns =
+                Object.keys(rel8ns || {}).length > 0 &&
+                Object.keys(rel8ns || {}).some(k => rel8ns![k] && rel8ns![k]!.length > 0);
+            const hasData = Object.keys((data) || {}).length > 0;
+            const ibHash = (await hashToHex(salt + ib)).toUpperCase();
+            // empty, null, undefined all treated the same at this level.
+            const rel8nsHash: string = hasRel8ns ? (await hashToHex(salt + JSON.stringify(rel8ns))).toUpperCase() : "";
+            // empty, null, undefined all treated the same at this level (though not farther down in data)
+            const dataHash: string = hasData ? (await hashToHex(salt + JSON.stringify(data))).toUpperCase() : "";
+            // if the ibgib has no rel8ns or data, the hash should be just of the ib itself.
+            const allHash = hasRel8ns || hasData ?
+                (await hashToHex(salt + ibHash + rel8nsHash + dataHash)).toUpperCase() :
+                (await hashToHex(salt + ibHash)).toUpperCase();
+            return allHash;
+        };
+    } else {
+        hashFields = async (ib: Ib, data: IbGibData_V1 | undefined, rel8ns: IbGibRel8ns_V1 | undefined) => {
+            const hasRel8ns =
+                Object.keys(rel8ns || {}).length > 0 &&
+                Object.keys(rel8ns || {}).some(k => rel8ns![k] && rel8ns![k]!.length > 0);
+            const hasData = Object.keys((data) || {}).length > 0;
+            const ibHash = (await hashToHex(ib)).toUpperCase();
+            // empty, null, undefined all treated the same at this level.
+            const rel8nsHash: string = hasRel8ns ? (await hashToHex(JSON.stringify(rel8ns))).toUpperCase() : "";
+            // empty, null, undefined all treated the same at this level (though not farther down in data)
+            const dataHash: string = hasData ? (await hashToHex(JSON.stringify(data))).toUpperCase() : "";
+            // if the ibgib has no rel8ns or data, the hash should be just of the ib itself.
+            const allHash = hasRel8ns || hasData ?
+                (await hashToHex(ibHash + rel8nsHash + dataHash)).toUpperCase() :
+                (await hashToHex(ibHash)).toUpperCase();
+            return allHash;
+        }
+    }
+    return hashFields(ibGib.ib, ibGib?.data, ibGib?.rel8ns);
+}
+
+/**
+ * I have one large-ish sha256 function for gibbing purposes
+ * (dream where metabootstrapping is better)
+ * this is just testing a function that is internal to the sha256v1 func.
+ * terrible as can be duplicated, but simple for now.
+ */
+export async function hashToHexCopy(
+    message: string | undefined
+): Promise<string | undefined> {
+    if (!message) { return ""; }
+    try {
+        const msgUint8 = new TextEncoder().encode(message);
+        const buffer = await subtle.digest('SHA-256', msgUint8);
+        const asArray = Array.from(new Uint8Array(buffer));
+        return asArray.map(b => b.toString(16).padStart(2, '0')).join('');
+    } catch (e) {
+        console.error(extractErrorMsg(e.message));
+        return undefined;
+    }
+};

package/src/V1/sha256v1.spec.mts

@@ -0,0 +1,221 @@
+/**
+ * Test basic hashing that is used when calculating V1 gib hashes
+ * using sha256.
+ *
+ * NOTE:
+ *   This only tests the node implementation, and manual testing
+ *   is required for browser until I get some kind of browser testing
+ *   going.
+ */
+import { IbGib_V1, IbGibRel8ns_V1 } from './types.mjs';
+import { sha256v1, hashToHexCopy } from './sha256v1.mjs';
+import { IbGibWithDataAndRel8ns, IbGibRel8ns } from '../types.mjs';
+import { getGib, getGibInfo } from './transforms/transform-helper.mjs';
+
+import { Factory_V1 as factory } from './factory.mjs';
+
+// #region Test Data
+
+const enum TestIbs {
+    ib = "ib",
+    some_test_string_here = "Some test string here.",
+}
+let testHashes_sha256_strings: { [key: string]: string | undefined } = {
+    [TestIbs.ib]: "765DBB8C38A58A5DC019D7B3133DFFB251D643CB291328AD8E86D4F05655E68B",
+    [TestIbs.some_test_string_here]: "E9D61315933F1E8ABCEAA51B2CDD711FBF63C82CBF8C359603907E6DED73DB30"
+};
+
+const ROOT_IBGIB_ADDR = "ib^gib";
+const EMPTY_REL8NS: any = {};
+const EMPTY_DATA: any = {};
+const UNDEFINED_DATA: undefined = undefined;
+const UNDEFINED_REL8NS: undefined = undefined;
+const NULL_DATA: null = null;
+const NULL_REL8NS: null = null;
+
+const FALSY_REL8NS = [EMPTY_REL8NS, UNDEFINED_REL8NS, NULL_REL8NS];
+const FALSY_DATA = [EMPTY_DATA, UNDEFINED_DATA, NULL_DATA];
+const FALSY_DATA_REL8NS: { r: IbGibRel8ns, d: any }[] = [];
+FALSY_REL8NS.forEach(r => {
+    FALSY_DATA.forEach(d => {
+        FALSY_DATA_REL8NS.push({ d, r });
+    })
+})
+
+interface DATA_FLAT_XY { x: number; y: number; }
+const DATA_FLAT_XY: DATA_FLAT_XY = { x: 1, y: 2 };
+const DATA_FLAT_XY_HASH = "689A8F1DB95402580476E38C264278CE7B1E664320CFB4E9AE8D3A908CF09964";
+interface DATA_FLAT_XS { x: number; s: string; }
+const DATA_FLAT_XS: DATA_FLAT_XS = { x: 1, s: "string here" };
+const DATA_FLAT_XS_HASH = "ACEB0CC65033DD85216F20CB333FA363F4AF5D601B8FBC053F9C0F10A4D6945F";
+const REL8NS_SIMPLE: IbGibRel8ns_V1 = {
+    past: [ROOT_IBGIB_ADDR],
+    ancestor: [ROOT_IBGIB_ADDR],
+    dna: [ROOT_IBGIB_ADDR],
+    identity: [ROOT_IBGIB_ADDR],
+}
+const REL8NS_SIMPLE_HASH = "54E74D958F5413212BFD9A5A692B77B5EAC070E82AEAF860D0EE2CCB6113FAFF";
+
+/**
+ * A little dogfooding interface for testing
+ */
+interface TestData {
+    type: "falsy_data_rel8ns" | "simple_data_rel8ns";
+    ibgib: IbGibWithDataAndRel8ns;
+    ibHash: string;
+    dataHash: string;
+    rel8nsHash: string;
+    salt?: string;
+}
+
+const TEST_IBGIBS: TestData[] = [
+    ...FALSY_DATA_REL8NS.map(x => {
+        return {
+            type: "falsy_data_rel8ns",
+            ibgib: {
+                ib: TestIbs.ib,
+                gib: testHashes_sha256_strings.ib,
+                rel8ns: x.r,
+            },
+            ibHash: testHashes_sha256_strings.ib,
+            dataHash: "",
+            rel8nsHash: "",
+        } as TestData;
+    }),
+    {
+        type: "simple_data_rel8ns",
+        ibgib: {
+            ib: TestIbs.ib,
+            gib: "6B4084CBE160723E10DC14E9B3FC5AFCE537BB41FC00150C5403C2A62D6BE759",
+            rel8ns: REL8NS_SIMPLE,
+            data: DATA_FLAT_XY,
+        },
+        ibHash: testHashes_sha256_strings[TestIbs.ib]!,
+        rel8nsHash: REL8NS_SIMPLE_HASH,
+        dataHash: DATA_FLAT_XY_HASH,
+    },
+    {
+        type: "simple_data_rel8ns",
+        ibgib: {
+            ib: TestIbs.ib,
+            gib: "A11967196EB5E5F1EC95A5BFA7DD9765B9B060DDAE736F597180BF9D6B53F4ED",
+            rel8ns: REL8NS_SIMPLE,
+            data: DATA_FLAT_XS,
+        },
+        ibHash: testHashes_sha256_strings[TestIbs.ib]!,
+        rel8nsHash: REL8NS_SIMPLE_HASH,
+        dataHash: DATA_FLAT_XS_HASH,
+    },
+]
+
+// #endregion
+
+describe(`when hashing sha256v1`, () => {
+
+    it(`should hash ibgibs with empty/null/undefined data/rel8ns consistently "forever"`, async () => {
+        const ib: string = "ib";
+        const gib: string = "gib ignored when hashing";
+        const ibHash: string = await hashToHexCopy(ib) || "";
+        const dataHash: string = "";
+        const rel8nsHash: string = "";
+        const all = (ibHash + rel8nsHash + dataHash).toUpperCase();
+        const manualAllHash = (await hashToHexCopy(all))?.toUpperCase();
+        expect(manualAllHash).toEqual("E975776B1A3E4468086E1D8C409116F6E098D13BEEDFE17AF668071B5D11CD55");
+
+        const equivalents: IbGib_V1[] = [
+            // #region empty rel8ns
+            {
+                ib, gib,
+                rel8ns: EMPTY_REL8NS
+            },
+            {
+                ib, gib,
+                rel8ns: EMPTY_REL8NS,
+                data: EMPTY_DATA,
+            },
+            {
+                ib, gib,
+                rel8ns: EMPTY_REL8NS,
+                data: NULL_DATA,
+            },
+            {
+                ib, gib,
+                rel8ns: EMPTY_REL8NS,
+                data: UNDEFINED_DATA,
+            },
+            // #endregion
+            // #region null rel8ns
+            {
+                ib, gib,
+                rel8ns: NULL_REL8NS,
+                data: EMPTY_DATA,
+            },
+            {
+                ib, gib,
+                rel8ns: NULL_REL8NS,
+                data: NULL_DATA,
+            },
+            {
+                ib, gib,
+                rel8ns: NULL_REL8NS,
+                data: UNDEFINED_DATA,
+            },
+            // #endregion
+            // #region undefined rel8ns
+            {
+                ib, gib,
+                rel8ns: UNDEFINED_REL8NS,
+                data: EMPTY_DATA,
+            },
+            {
+                ib, gib,
+                rel8ns: UNDEFINED_REL8NS,
+                data: NULL_DATA,
+            },
+            {
+                ib, gib,
+                rel8ns: UNDEFINED_REL8NS,
+                data: UNDEFINED_DATA,
+            },
+            // #endregion
+        ]
+        // someday change this to use the TEST_IBGIBS
+        for (let j = 0; j < equivalents.length; j++) {
+            const ibgib = equivalents[j];
+            const result = (await sha256v1(ibgib, "")).toUpperCase();
+            expect(result).toEqual(manualAllHash!);
+        }
+    });
+
+    it(`should hash ibgibs with non-null data/rel8ns consistently "forever"`, async () => {
+        for (const x of TEST_IBGIBS.filter(x => x.type === "simple_data_rel8ns")) {
+            const ibHash: string = await hashToHexCopy(x.ibgib.ib) || "";
+            const dataHash: string = await hashToHexCopy(JSON.stringify(x.ibgib.data)) || "";
+            expect(dataHash.toUpperCase()).toEqual(x.dataHash);
+            const rel8nsHash: string = await hashToHexCopy(JSON.stringify(x.ibgib.rel8ns)) || "";
+            expect(rel8nsHash.toUpperCase()).toEqual(x.rel8nsHash);
+            const all = (ibHash + rel8nsHash + dataHash).toUpperCase();
+            const manualAllHash = (await hashToHexCopy(all))?.toUpperCase();
+            expect(manualAllHash).toEqual(x.ibgib.gib);
+
+            const calculatedGibHash = (await sha256v1(x.ibgib, "")).toUpperCase();
+            expect(calculatedGibHash).toEqual(x.ibgib.gib!);
+        }
+    });
+
+    // I have one large-ish sha256 function for gibbing purposes instead of my usual
+    // breaking down into multiple smaller functions. This is specifically with having
+    // function ibgibs in mind, where the textual code is in the ibgib format
+    // (ib, gib, data, rel8ns).
+    // (dream where metabootstrapping is better)
+    // this is testing a function that is internal to the sha256v1 func.
+    // terrible as can be duplicated (i.e. not DRY), but simple albeit fragile testing
+    // for now.
+    Object.keys(testHashes_sha256_strings).forEach(x => {
+        it(`test internal hash function ib: ${x}`, async () => {
+            const result = await hashToHexCopy(x);
+            expect(result?.toUpperCase()).toEqual(testHashes_sha256_strings[x]);
+        });
+    });
+
+});

package/src/V1/transforms/fork.mts

@@ -0,0 +1,100 @@
+import { getIbGibAddr, clone, getUUID, getTimestamp } from '../../helper.mjs';
+import { sha256v1 } from '../sha256v1.mjs';
+import { IbGib_V1, IbGibData_V1, IbGibRel8ns_V1, Rel8n } from '../types.mjs';
+import { TransformOpts_Fork, TransformResult } from '../../types.mjs';
+import { IBGIB_DELIMITER, ROOT_ADDR } from '../constants.mjs';
+import { buildDna } from './transform-helper.mjs';
+
+/**
+ * Original-ish V1 transform behavior.
+ * Going to create an ibGib containing the fork data.
+ * Apply that fork and create a resulting ibGib.
+ *
+ * Takes the src ibGib, clears its past and adds a link to
+ * the src via the 'ancestor' rel8n.
+ *
+ * NOTE:
+ *   This is NOT going to do the plan^gib stuff ATM.
+ *   Also this does NOT add any identity information ATM.
+ */
+export async function fork(opts: TransformOpts_Fork<IbGib_V1>): Promise<TransformResult<IbGib_V1>> {
+    const {
+        noTimestamp, dna,
+        linkedRel8ns,
+        destIb, uuid, tjp,
+        cloneRel8ns, cloneData,
+        type = 'fork',
+    } = opts;
+    let src = opts.src;
+
+    const lc = '[fork_v1]';
+    // #region validation
+    if (type !== 'fork') { throw new Error(`${lc} not a fork transform.`); }
+    if (!opts.type) { opts.type = 'fork' }
+
+    if (!src) { throw new Error(`${lc} src required to fork.`); }
+    if (!src!.ib) { throw new Error(`${lc} src.ib required.`); }
+    // destIb is not required, as it just reuses src.ib
+    if (destIb && destIb.includes(IBGIB_DELIMITER)) {
+        throw new Error(`${lc} destIb can't contain (hardcoded) delimiter right now.`);
+    }
+    if (!src!.gib) { throw new Error(`${lc} src.gib required.`); }
+
+    // #endregion
+
+    // we want to forget `src` proper very quickly because it may have other
+    // non-IbGib properties that are not relevant to our transform.
+    let dto: IbGib_V1 = { ib: src.ib, gib: src.gib, };
+    if (src.data && Object.keys(src.data).length > 0) { dto.data = src.data; }
+    if (src.rel8ns && Object.keys(src.rel8ns).length > 0) { dto.rel8ns = src.rel8ns; }
+    src = dto;
+
+    const srcAddr = getIbGibAddr({ ib: src!.ib, gib: src.gib });
+    opts.srcAddr = srcAddr;
+
+    const rel8ns: IbGibRel8ns_V1 =
+        cloneRel8ns && src.rel8ns && Object.keys(src.rel8ns).length > 0 ?
+            clone(src.rel8ns) :
+            {};
+    const data: any = cloneData && src?.data ? clone(src!.data) : {};
+    if (opts.nCounter) { data.n = 0; }
+    const ancestor = linkedRel8ns?.includes(Rel8n.ancestor) ?
+        [srcAddr] :
+        (rel8ns.ancestor || []).concat([srcAddr]);
+    rel8ns.ancestor = ancestor;
+
+    // remove tjp if exists in rel8ns
+    if (rel8ns.tjp) { delete rel8ns.tjp; }
+
+    const newIbGib = clone(src) as IbGib_V1<IbGibData_V1>;
+    if (noTimestamp && tjp?.timestamp) {
+        throw new Error(`${lc} both noTimestamp and tjp.timestamp selected.`);
+    }
+    if (!noTimestamp || tjp?.timestamp) { data.timestamp = getTimestamp(); }
+    if (tjp?.uuid || uuid) { data.uuid = await getUUID(); }
+    if (tjp?.uuid || tjp?.timestamp) {
+        data.isTjp = true;
+    } else {
+        if (data.isTjp) { delete data.isTjp; }
+    }
+
+    newIbGib.ib = destIb || 'ib';
+    // rel8ns ignored if forking from the root ib^gib
+    if (srcAddr !== ROOT_ADDR) { newIbGib.rel8ns = rel8ns; }
+    if (Object.keys(data).length > 0) { newIbGib.data = data; }
+
+    let transformDna: IbGib_V1 | null = null;
+    if (dna) {
+        transformDna = await buildDna(opts);
+        const dnaAddr = getIbGibAddr({ ibGib: transformDna });
+        rel8ns.dna = linkedRel8ns?.includes(Rel8n.dna) ?
+            rel8ns.dna = [dnaAddr] :
+            rel8ns.dna = (rel8ns.dna || []).concat(dnaAddr);
+    }
+
+    newIbGib.gib = await sha256v1(newIbGib, '');
+
+    const result: TransformResult<IbGib_V1> = { newIbGib };
+    if (transformDna) { result.dnas = [transformDna!] }
+    return result;
+}