@ibgib/ts-gib 0.4.9 → 0.5.0

package/src/helper.mts

@@ -1,19 +1,6 @@
 import { Ib, Gib, IbGib, IbGibAddr, IbAndGib } from './types.mjs';
-let crypto: any = globalThis.crypto;
-let { subtle } = crypto;
 
-export type HashAlgorithm = 'SHA-256' | 'SHA-512';
-export const HashAlgorithm: { [key: string]: HashAlgorithm } = {
-    'sha_256': 'SHA-256' as HashAlgorithm,
-    'sha_512': 'SHA-512' as HashAlgorithm,
-}
 
-export function clone(obj: any) {
-    return JSON.parse(JSON.stringify(obj));
-}
-export function getTimestamp() {
-    return (new Date()).toUTCString();
-}
 /**
  * Gets the ib^gib address from the given ib and gib or
  * from the ibGib object.
@@ -87,106 +74,3 @@ export function getIbAndGib({
         }
     }
 }
-
-/**
- * Simple hash function.
- *
- * NOTE:
- *   This is not used for ibGib.gib values (ATOW)
- *   but rather as a helper function for generating random UUIDs.
- *
- * @param s string to hash
- * @param algorithm to use, currently only 'SHA-256'
- */
-export async function hash({
-    s,
-    algorithm = 'SHA-256',
-}: {
-    s: string,
-    algorithm?: HashAlgorithm,
-}): Promise<string> {
-    if (!s) { return ''; }
-
-    const validAlgorithms = Object.values(HashAlgorithm);
-    if (!validAlgorithms.includes(algorithm)) {
-        console.error(`Only ${validAlgorithms} implemented`); return '';
-    }
-    try {
-        const msgUint8 = new TextEncoder().encode(s);
-        const buffer = await subtle.digest(algorithm, 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 '';
-    }
-}
-
-/**
- * Simple func to generate UUID (sha-256 hash basically).
- *
- * @param seedSize size of seed for UUID generation
- */
-export async function getUUID(seedSize = 64): Promise<string> {
-    let uuid: string = '';
-    if (seedSize < 32) { throw new Error(`Seed size must be at least 32`); }
-    if (!globalThis.crypto) { throw new Error(`Cannot create UUID, as unknown crypto library version. If using node.js, v19+ is required. (E: c02cee3fd8a94f678d3f4ebe9dc49797)`); }
-
-    const values = crypto.getRandomValues(new Uint8Array(16));
-    uuid = await hash({ s: values.join('') });
-
-    if (!uuid) { throw new Error(`Did not create UUID...hmm...`); }
-
-    return uuid;
-}
-
-/**
- * Syntactic sugar for JSON.stringify(obj, null, 2);
- *
- * @param obj to pretty stringify
- */
-export function pretty(obj: any): string {
-    return JSON.stringify(obj, null, 2);
-}
-
-/**
- * Just delays given number of ms.
- *
- * @param ms milliseconds to delay
- */
-export async function delay(ms: number): Promise<void> {
-    return new Promise<void>(resolve => {
-        setTimeout(() => {
-            resolve();
-        }, ms);
-    });
-}
-
-/**
- * extracts the error message from an error object/string/falsy arg.
- *
- * ## notes
- *
- * * some libs throw errors, some throw just strings.
- * * who knows what else it could be.
- *
- * ## todo
- *
- * * extract inner errors/causes if we ever use this function extensively.
- *
- * @param error the error object in the catch area of the try..catch block.
- * @returns error.message if it's a string, error itself if it's a string, or canned error messages if it's falsy or none of the above.
- */
-export function extractErrorMsg(error: any): string {
-    if (!error && error !== 0) {
-        return '[error is falsy]';
-    } else if (typeof error === 'string') {
-        return error;
-    } else if (typeof error.message === 'string') {
-        return error.message;
-    } else if (typeof error === 'number') {
-        return JSON.stringify(error);
-    } else {
-        return `[error is not a string and error.message is not a string. typeof error: ${typeof error}]`;
-    }
-}

package/src/helper.spec.mts

@@ -1,127 +1,59 @@
-/**
- * Test helper functions.
- */
+import { getIbAndGib, getIbGibAddr } from './helper.mjs';
+import { Ib, IbGib } from './types.mjs';
+import { ROOT, ROOT_ADDR } from './V1/constants.mjs';
 
-import * as h from './helper.mjs';
-import { HashAlgorithm } from './helper.mjs';
 
-const SOME_STRING = "This is some stringy stuff...";
-const SOME_STRING_HASH = "5DC14EA1027B956AD6BA51F11372DF823FCF3429B5F2063F1DDA358E0F4F2992";
-const SOME_STRING_HASH_512 = "C48C780DA7C43EE7047CDAB0D7A2FDF5DC050DF3291D3CAE973FB0F51BE8535668592EB25A730C95A23D3B4D57924893E7E87C86DC0F52C6D5D2E34EE41203E5";
-const SOME_OTHER_STRING = "This is quite a different string of stuff.";
-const TEST_HASHES: { [key: string]: string } = {
-    [SOME_STRING + h.HashAlgorithm.sha_256]: SOME_STRING_HASH,
-    [SOME_STRING + h.HashAlgorithm.sha_512]: SOME_STRING_HASH_512,
-    [SOME_OTHER_STRING + h.HashAlgorithm.sha_256]: 'AE4C18B37B2329770E05EA3F946C6EB6DE56D2DC568E1F5CBB395E2A1556F58A',
-    [SOME_OTHER_STRING + h.HashAlgorithm.sha_512]: '2F1A72B21C914ED459319DF4B5D70E81CEE67C4B48BC74CD6BA8F41DCEC20DCD100C914913F370B2782985268D05C590B46F3FE9005A7477BA952935D2454E53',
-}
+describe(`getIbGibAddr`, () => {
+    // unsure if these would change when not in V1...(these tests are outside V1 atow)
 
-describe(`when cloning`, () => {
-
-    it(`should copy deep objects`, async () => {
-        const objSimple = { a: SOME_STRING };
-        const objADeep = {
-            levelOne: {
-                levelTwo: {
-                    buckle: "your shoe",
-                    three: "four",
-                    objSimple: objSimple,
-                }
-            }
-        };
-        const cloneADeep = h.clone(objADeep);
-        expect(cloneADeep?.levelOne?.levelTwo?.buckle).toBe("your shoe");
-        expect(cloneADeep?.levelOne?.levelTwo?.three).toBe("four");
-        expect(cloneADeep?.levelOne?.levelTwo?.objSimple).toEqual(objSimple);
-
-        cloneADeep.levelOne.levelTwo.objSimple.a = SOME_OTHER_STRING;
-
-        // original should **still** be the first value
-        expect(objSimple.a).toBe(SOME_STRING);
-        // clone should be changed.
-        expect(cloneADeep.levelOne.levelTwo.objSimple.a).toBe(SOME_OTHER_STRING);
-    });
-});
-
-describe(`when getting timestamp`, () => {
-    it(`should get the current date as UTCString`, async () => {
-        // implementation detail hmm....
-        const timestamp = h.getTimestamp();
-        const date = new Date(timestamp);
-        const dateAsUTCString = date.toUTCString();
-        expect(timestamp).toBe(dateAsUTCString);
+    it(`should get the right addr for ROOT`, async () => {
+        let ibGib = ROOT;
+        let gotten = getIbGibAddr({ ibGib });
+        expect(gotten).toBeTruthy();
+        expect(gotten).toEqual(ROOT_ADDR);
     });
-});
-
-describe(`when hashing (helper)`, () => {
-    const TEST_ALGORITHMS: h.HashAlgorithm[] = Object.values(h.HashAlgorithm);
 
-    // implicit is just SHA-256
-    it(`should hash consistently with implicit SHA-256`, async () => {
-        const hash = await h.hash({ s: SOME_STRING }) || "";
-        expect(hash.toUpperCase()).toBe(TEST_HASHES[SOME_STRING + 'SHA-256']);
+    it(`should get the right addr for primitives`, async () => {
+        let ibs: Ib[] = ['7', 'foo', 'ibgib', 'wakka doodle'];
+        for (let i = 0; i < ibs.length; i++) {
+            const ib = ibs[i];
+            let ibGib: IbGib = { ib, gib: 'gib' };
+            let gotten = getIbGibAddr({ ibGib });
+            expect(gotten).toBeTruthy();
+            expect(gotten).toEqual(`${ib}^gib`);
+        }
     });
 
-    for (let algorithm of TEST_ALGORITHMS) {
-        it(`should hash consistently with explicit ${algorithm}`, async () => {
-            // const hash = await h.hash({s: SOME_STRING, algorithm: "SHA-256"}) || "";
-            let hash = await h.hash({ s: SOME_STRING, algorithm }) || "";
-            expect(hash.toUpperCase()).toBe(TEST_HASHES[SOME_STRING + algorithm]);
-            hash = await h.hash({ s: SOME_OTHER_STRING, algorithm }) || "";
-            expect(hash.toUpperCase()).toBe(TEST_HASHES[SOME_OTHER_STRING + algorithm]);
-        });
-        it(`should hash without collisions, 1000 times, ${algorithm}`, async () => {
-            const hashes: string[] = [];
-            const salt = await h.getUUID(1024);
-            // console.log(`salt: ${salt}`);
-            for (let i = 0; i < 1000; i++) {
-                const hash = await h.hash({ s: salt + i.toString(), algorithm }) || "";
-                // console.log(hash);
-                expect(hashes).not.toContain(hash);
-                hashes.push(hash);
-            }
-        });
-    };
 });
 
-describe(`when generating UUIDs`, () => {
-    it(`shouldn't duplicate UUIDs`, async () => {
-        const ids: string[] = [];
-        for (let i = 0; i < 100; i++) {
-            const id = await h.getUUID();
-            expect(ids).not.toContain(id);
-            ids.push(id);
+describe(`getIbAndGib`, () => {
+    // unsure if these would change when not in V1...(these tests are outside V1 atow)
+
+    it(`should get the right ib & gib for ROOT, with ibGib param`, async () => {
+        let ibGib = ROOT;
+        let gotten = getIbAndGib({ ibGib });
+        expect(gotten).toBeTruthy();
+        expect(gotten.ib).toEqual('ib');
+        expect(gotten.gib).toEqual('gib');
+    });
+
+    it(`should get the right ib & gib for ROOT_ADDR, with ibGibAddr param`, async () => {
+        let gotten = getIbAndGib({ ibGibAddr: ROOT_ADDR });
+        expect(gotten).toBeTruthy();
+        expect(gotten.ib).toEqual('ib');
+        expect(gotten.gib).toEqual('gib');
+    });
+
+    it(`should get the right ib & gib for primitives`, async () => {
+        let ibs: Ib[] = ['7', 'foo', 'ibgib', 'wakka doodle'];
+        for (let i = 0; i < ibs.length; i++) {
+            const ib = ibs[i];
+            let ibGib: IbGib = { ib, gib: 'gib' };
+            let gotten = getIbAndGib({ ibGib });
+            expect(gotten).toBeTruthy();
+            expect(gotten.ib).toEqual(ib);
+            expect(gotten.gib).toEqual('gib');
         }
     });
-});
 
-describe(`when extractErrorMsg`, () => {
-    it(`should return canned msg when error is falsy`, () => {
-        const defaultMsg = '[error is falsy]'; // duplicate of code in helper.mjs
-        [null, undefined, ''].forEach(error => {
-            expect(h.extractErrorMsg(error)).withContext(JSON.stringify(error)).toEqual(defaultMsg);
-        });
-    });
-    it(`should return incoming error if it is a string`, () => {
-        ['string here', 'undefined', '42', 'ibgib'].forEach(stringError => {
-            expect(h.extractErrorMsg(stringError)).withContext(JSON.stringify(stringError)).toEqual(stringError);
-        });
-    });
-    it(`should return error.message if it's a thrown error`, () => {
-        ['string here', 'undefined', 'something went wrong', 'danger. out of memory (E: ce86ffd7a0174c1d8ce5e56c807dd4b1)']
-            .map(x => new Error(x))
-            .forEach(error => {
-                expect(h.extractErrorMsg(error)).withContext(error.message).toEqual(error.message);
-            });
-    });
-    it(`should return incoming error stringified if it is a number`, () => {
-        [1234, 0, 1_000, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER, -5, 1 / 23].forEach(numberError => {
-            expect(h.extractErrorMsg(numberError)).withContext(JSON.stringify(numberError)).toEqual(JSON.stringify(numberError));
-        });
-    });
-    it(`should return canned response with type if incoming error is none of the above`, () => {
-        let error = { x: 1, y: 2 };
-        let msg = h.extractErrorMsg(error);
-        expect(msg).withContext(JSON.stringify(error)).toBeTruthy();
-    });
-});
+});

package/src/types.mts

@@ -1,17 +1,44 @@
 /**
- * The core of the simplicity of the ibGib protocol is that
- * fundamentally you are taking two ibGibs and producing a third.
+ * @module types
  *
- * There are three primary functions: mut8, rel8, fork
+ * These are the core types at the lowest level of the ibGib protocol.
  *
- * These are actually different aspects of the single function of
- * relationship and time, either extending or creating a timeline.
+ * The core of the simplicity of the ibGib protocol is that fundamentally you
+ * are encompassing the idea of an ibgib (similar to a base class "object" or
+ * "thing") that has intrinsic data and relationships to extrinsic ibgib.  Each
+ * ibgib is content addressed with a unique addressing style called its ib^gib
+ * address. This allows us semantics for abstracting the "content addressing"
+ * per use case, with various schemas allowed, but in general the `ib` is
+ * per-use-case metadata and the `gib` is the more conventional hash of the
+ * ibgib record to allow for the cryptographic guarantees one would expect. Each
+ * discrete frame in time of the ibgib is its own ibgib, and a timeline stream
+ * of that ibgib is created via the "past" relationship (`rel8n`).
  *
- * Mut8 is intrinsic, rel8 is extrinsic, fork is a new timeline.
- * Mut8 changes a timeline, rel8 changes a timeline's link(s),
- * fork creates a new timeline.
+ * New ibgib records are created via "transforms", of which atow there are three
+ * kinds: `mut8`, `rel8`, `fork`
+ *
+ * These are actually different aspects of the single function of relationship
+ * and time, either extending or creating a timeline.
+ *
+ * Mut8 is intrinsic, rel8 is extrinsic, fork makes a new timeline.  Mut8
+ * changes a timeline, rel8 changes a timeline's link(s), fork creates a new
+ * timeline.
+ *
+ * ## notes
+ *
+ * I have attempted to make these version independent, though we will not know
+ * how successful that is until we do a V2.
+ */
+
+/**
+ * Type alias of string (or empty string) that is meant to convey that it
+ * is used as the ib in an ib^gib address or an `IbGib` class.
  */
 export declare type Ib = '' | string;
+/**
+ * Type alias of string (or empty string) that is meant to convey that it
+ * is used as the gib in an ib^gib address or an `IbGib` class.
+ */
 export declare type Gib = '' | 'gib' | string;
 /**
  * Convenient for when destructuring an IbGibAddr
@@ -27,6 +54,11 @@ export interface IbAndGib {
  * that's to decide for future.
  */
 export declare type IbGibAddr = string;
+/**
+ * Type alias that indicates that this is intended to be a tjp (temporal
+ * junction point) address.
+ */
+export declare type TjpIbGibAddr = IbGibAddr;
 export declare type IbGibRel8ns = {
     /**
      * The key is the rel8nName.
@@ -224,7 +256,6 @@ export interface TransformOpts_Rel8<TSrc extends IbGib = IbGib> extends Transfor
      */
     rel8nsToRemoveByAddr?: IbGibRel8ns;
 }
-
 export interface TransformResult<TOut extends IbGib> {
     /**
      * The final result of the transformation

package/dist/index.cjs

@@ -1,4 +0,0 @@
-export * as V1 from './V1/index.mjs';
-export * from './types.mjs';
-export * from './helper.mjs';
-//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../src/index.cts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACrC,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC"}

package/dist/index.d.cts

@@ -1,4 +0,0 @@
-export * as V1 from './V1/index.mjs';
-export * from './types.mjs';
-export * from './helper.mjs';
-//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../src/index.cts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACrC,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC"}

package/src/index.cts

@@ -1,3 +0,0 @@
-export * as V1 from './V1/index.mjs';
-export * from './types.mjs';
-export * from './helper.mjs';