@ibgib/core-gib 0.0.113 → 0.1.2

package/src/witness/space/metaspace/metaspace-innerspace/metaspace-innerspace-helper.mts

@@ -1,12 +1,15 @@
 import { extractErrorMsg, getUUID, pretty } from "@ibgib/helper-gib/dist/helpers/utils-helper.mjs";
-import { getGib } from "@ibgib/ts-gib/dist/V1/transforms/transform-helper.mjs";
+import { getGib, getGibInfo } from "@ibgib/ts-gib/dist/V1/transforms/transform-helper.mjs";
 import { GIB } from "@ibgib/ts-gib/dist/V1/constants.mjs";
 
 import { IbGibSpaceAny } from "../../../../witness/space/space-base-v1.mjs";
 import { DtoToSpaceFunction, LocalSpaceFactoryFunction } from "../metaspace-types.mjs";
 import { spaceNameIsValid } from "../../../../witness/space/space-helper.mjs";
 import { DEFAULT_LOCAL_SPACE_POLLING_INTERVAL_MS, } from "../../../../witness/space/space-constants.mjs";
-import { InnerSpace_V1, InnerSpace_V1_Data } from "../../inner-space/inner-space-v1.mjs";
+import { InnerSpace_V1, } from "../../inner-space/inner-space-v1.mjs";
+import { InnerSpaceData_V1 } from "../../inner-space/inner-space-types.mjs";
+
+const innerSpaces: { [tjpGib: string]: IbGibSpaceAny } = {};
 
 export const fnCreateNewLocalSpace: LocalSpaceFactoryFunction = async ({
     allowCancel,
@@ -49,7 +52,7 @@ Enter space name:
         }
 
         // ...create in memory with defaults
-        const data: InnerSpace_V1_Data = {
+        const data: InnerSpaceData_V1 = {
             version: '1',
             name: spaceName || ('in-memory-space_' + (await getUUID()).slice(0, 10)),
             uuid: await getUUID(),
@@ -70,6 +73,10 @@ Enter space name:
         if (newLocalSpace.gib === GIB) { throw new Error(`localSpace.gib not updated correctly.`); }
         if (logalot) { console.log(`${lc} localSpace.gib: ${newLocalSpace.gib} (after sha256v1)`); }
 
+        const gibInfo = getGibInfo({ gib: newLocalSpace.gib });
+        const tjpGib = gibInfo.tjpGib ?? newLocalSpace.gib!;
+        innerSpaces[tjpGib] = newLocalSpace;
+
         return newLocalSpace as IbGibSpaceAny;
     } catch (error) {
         console.error(`${lc} ${error.message}`);
@@ -79,6 +86,7 @@ Enter space name:
     }
 }
 
+
 export const fnDtoToSpace: DtoToSpaceFunction = async (spaceDto) => {
     const lc = `[fnDtoToSpace]`;
 
@@ -87,14 +95,28 @@ export const fnDtoToSpace: DtoToSpaceFunction = async (spaceDto) => {
         // return the reference itself.
         if ((spaceDto as InnerSpace_V1).ibGibs) {
             return spaceDto as InnerSpace_V1;
-        }
+        } else {
+            console.log(`${lc} spaceDto: ${pretty(spaceDto)} (I: d69ab87f2fa8360ff8e60e78aa15c825)`);
+
+            if (!spaceDto.data) { throw new Error(`invalid spaceDto. InnerSpace_V1 should have truthy data. (E: d402fda7a6a53668b655c2885029a423)`); }
+            console.dir(spaceDto);
 
-        // it's not the reference, so make a new one? (but warn)
-        console.warn(`${lc} in memory innerspace dto that isnt' the reference to the object itself in memory? (W: b8973f3a43f546eeaf59f60331896e75)`)
-        if (!spaceDto.data) { throw new Error(`invalid spaceDto. InnerSpace_V1 should have truthy data. (E: d402fda7a6a53668b655c2885029a423)`); }
-        let space = new InnerSpace_V1(spaceDto.data as InnerSpace_V1_Data, undefined);
-        await space.initialized;
-        return space;
+            const gibInfo = getGibInfo({ gib: spaceDto.gib });
+            const tjpGib = gibInfo.tjpGib ?? spaceDto.gib!;
+            const existingSpace = innerSpaces[tjpGib];
+            if (existingSpace) {
+                return existingSpace;
+            } else {
+                // it's not the reference and nothing registered so far, so make a new one? (but warn)
+                console.warn(`${lc} in memory innerspace dto that isnt' the reference to the object itself in memory, and we don't have it in the inner spaces map? i guess we'll create a new one from the dto (W: b8973f3a43f546eeaf59f60331896e75)`)
+                let space = new InnerSpace_V1(spaceDto.data as InnerSpaceData_V1, spaceDto.rel8ns);
+                await space.initialized;
+                const gibInfo = getGibInfo({ gib: space.gib });
+                const tjpGib = gibInfo.tjpGib ?? space.gib!;
+                innerSpaces[tjpGib] = space;
+                return space;
+            }
+        }
     } catch (error) {
         console.error(`${lc} ${extractErrorMsg(error)}`);
         throw error;

package/src/witness/space/metaspace/metaspace-innerspace/metaspace-innerspace.mts

@@ -23,66 +23,89 @@ const logalot = GLOBAL_LOG_A_LOT;
  */
 export class Metaspace_Innerspace extends MetaspaceBase {
 
-  // we won't get an object back, only a DTO ibGib essentially
-  protected lc: string = `[${Metaspace_Innerspace.name}]`;
+    // we won't get an object back, only a DTO ibGib essentially
+    protected lc: string = `[${Metaspace_Innerspace.name}]`;
 
-  /**
-   * since this is an in-memory metaspace, we always return the same instance
-   * for the zero space.
-   */
-  private _zeroSpace: InnerSpace_V1 | undefined;
+    /**
+     * since this is an in-memory metaspace, we always return the same instance
+     * for the zero space.
+     */
+    private _zeroSpace: InnerSpace_V1 | undefined;
 
-  /**
-   * since this is an in-memory metaspace, we always return the same instance
-   *
-   * returns this._zeroSpace
-   */
-  get zeroSpace(): IbGibSpaceAny {
-    const lc = `${this.lc}[get zeroSpace]`;
-    if (!this._zeroSpace) { throw new Error(`${lc} this._zeroSpace falsy. should have been created on this.initialize (E: e723177fd2a74e25eb25e2299dfa4d23)`); }
-    return this._zeroSpace;
-  }
+    /**
+     * since this is an in-memory metaspace, we always return the same instance
+     *
+     * returns this._zeroSpace
+     */
+    get zeroSpace(): IbGibSpaceAny {
+        const lc = `${this.lc}[get zeroSpace]`;
+        if (!this._zeroSpace) { throw new Error(`${lc} this._zeroSpace falsy. should have been created on this.initialize (E: e723177fd2a74e25eb25e2299dfa4d23)`); }
+        return this._zeroSpace;
+    }
 
-  constructor(
-    protected cacheSvc: IbGibCacheService | undefined,
-  ) {
-    super(cacheSvc);
-    const lc = `${this.lc}[ctor]`;
-    if (logalot) {
-      console.log(`${lc} ${GLOBAL_TIMER_NAME}`);
-      console.timeLog(GLOBAL_TIMER_NAME);
-      console.log(`${lc} created.`);
+    constructor(
+        protected cacheSvc: IbGibCacheService | undefined,
+    ) {
+        super(cacheSvc);
+        const lc = `${this.lc}[ctor]`;
+        if (logalot) {
+            console.log(`${lc} ${GLOBAL_TIMER_NAME}`);
+            console.timeLog(GLOBAL_TIMER_NAME);
+            console.log(`${lc} created.`);
+        }
     }
-  }
 
-  protected async initializeMetaspaceFactory({ metaspaceFactory }: {
-    metaspaceFactory: MetaspaceFactory,
-  }): Promise<void> {
-    const lc = `[${this.initializeMetaspaceFactory.name}]`;
-    try {
-      if (logalot) { console.log(`${lc} starting... (I: 5a29670439ac47634dcdfe25225c8223)`); }
+    protected async initializeMetaspaceFactory({ metaspaceFactory }: {
+        metaspaceFactory: MetaspaceFactory,
+    }): Promise<void> {
+        const lc = `[${this.initializeMetaspaceFactory.name}]`;
+        try {
+            if (logalot) { console.log(`${lc} starting... (I: 5a29670439ac47634dcdfe25225c8223)`); }
+
+            metaspaceFactory ??= {}
+            metaspaceFactory.fnDefaultLocalSpaceFactory ??=
+                (opts) => fnCreateNewLocalSpace(opts);
+            metaspaceFactory.fnDtoToSpace ??=
+                (spaceDto) => fnDtoToSpace(spaceDto);
+            metaspaceFactory.fnZeroSpaceFactory ??= () => {
+                if (this._zeroSpace) {
+                    return this._zeroSpace;
+                } else {
+                    // return this._zeroSpace!
+                    const zeroSpace = new InnerSpace_V1(/*initialData*/ undefined as any, /*initialRel8ns*/ undefined);
+                    zeroSpace.gib = 'gib';
+                    this._zeroSpace = zeroSpace;
+                    return zeroSpace;
+                }
+            };
 
-      await super.initializeMetaspaceFactory({ metaspaceFactory });
+            await super.initializeMetaspaceFactory({ metaspaceFactory });
 
-      metaspaceFactory.fnDefaultLocalSpaceFactory ??= (opts) => fnCreateNewLocalSpace(opts);
-      metaspaceFactory.fnDtoToSpace ??= (spaceDto) => fnDtoToSpace(spaceDto);
+            if (this.metaspaceFactory.fnZeroSpaceFactory) {
+                this._zeroSpace = this.metaspaceFactory.fnZeroSpaceFactory!() as InnerSpace_V1;
+            } else {
+                this._zeroSpace = await fnCreateNewLocalSpace({
+                    allowCancel: false,
+                    spaceName: 'in-memory-space_' + (await getUUID()).slice(0, 10),
+                    logalot,
+                    getFnPrompt: () => this.getFnPrompt!(),
+                }) as InnerSpace_V1;
+                if (!this._zeroSpace) { throw new Error(`(UNEXPECTED) create this._zeroSpace is falsy but no error after create? (E: 63c27616be41564377f843baa6725423)`); }
 
-      if (this.metaspaceFactory.fnZeroSpaceFactory) {
-        this._zeroSpace = this.metaspaceFactory.fnZeroSpaceFactory!() as InnerSpace_V1;
-      } else {
-        this._zeroSpace = await fnCreateNewLocalSpace({
-          allowCancel: false,
-          spaceName: 'in-memory-space_' + (await getUUID()).slice(0, 10),
-          logalot,
-          getFnPrompt: () => this.getFnPrompt!(),
-        }) as InnerSpace_V1;
-        if (!this._zeroSpace) { throw new Error(`(UNEXPECTED) create this._zeroSpce is falsy but no error after create? (E: 63c27616be41564377f843baa6725423)`); }
-      }
-    } catch (error) {
-      console.error(`${lc} ${error.message}`);
-      throw error;
-    } finally {
-      if (logalot) { console.log(`${lc} complete.`); }
+                // don't think this is necessary but...
+                // metaspaceFactory.fnZeroSpaceFactory = () => {
+                //     // return this._zeroSpace!
+                //     const zeroSpace = new InnerSpace_V1(/*initialData*/ undefined as any, /*initialRel8ns*/ undefined);
+                //     zeroSpace.gib = 'gib';
+                //     return zeroSpace;
+                // };
+            }
+            await this._zeroSpace.initialized;
+        } catch (error) {
+            console.error(`${lc} ${error.message}`);
+            throw error;
+        } finally {
+            if (logalot) { console.log(`${lc} complete.`); }
+        }
     }
-  }
 }