Don't init child keyvals in first keyval body call

Author: zerobias

packages/core/src/index.ts

@@ -5,4 +5,4 @@ export { lens } from './lens';
 export { lazy } from './lazy';
 export { createContext, readContext, setContext } from './context';
 export { spawn } from './spawn';
-export { InputType, KeyvalWithState } from './types';
+export type { InputType, KeyvalWithState } from './types';

packages/core/src/keyval.ts

@@ -104,15 +104,29 @@ export function keyval<Input, ModelEnhance, Api, Shape>(
     isClone: boolean,
     cloneOf: Keyval<any, any, any, any> | null,
   ) => {
+    type Enriched = Input & ModelEnhance;
+    type Output = {
+      [K in keyof ModelEnhance]:
+        | Store<ModelEnhance[K]>
+        | Keyval<any, ModelEnhance[K], any, any>;
+    };
+    type KeyvalListState = ListState<Enriched, Output, Api>;
+    const $entities = createStore<KeyvalListState>({
+      items: [],
+      instances: [],
+      keys: [],
+    });
+    const $items = $entities.map(({ items }) => items);
+    const $keys = $entities.map(({ keys }) => keys);
     return lazyInit(
       {
         type: 'keyval',
         api: 0,
         __lens: 0,
         __struct: 0,
-        $items: 0,
-        $keys: 0,
-        __$listState: 0,
+        $items,
+        $keys,
+        __$listState: $entities,
         defaultState: () => null as any,
         edit: 0,
         editField: 0,
@@ -141,12 +155,7 @@ export function keyval<Input, ModelEnhance, Api, Shape>(
             create,
           } = options as Exclude<typeof options, Keyval<any, any, any, any>>);
         }
-        type Enriched = Input & ModelEnhance;
-        type Output = {
-          [K in keyof ModelEnhance]:
-            | Store<ModelEnhance[K]>
-            | Keyval<any, ModelEnhance[K], any, any>;
-        };
+
         let kvModel:
           | Model<
               {
@@ -157,7 +166,7 @@ export function keyval<Input, ModelEnhance, Api, Shape>(
               Shape
             >
           | undefined;
-        type KeyvalListState = ListState<Enriched, Output, Api>;
+
         if (create) {
           // @ts-expect-error typecast
           kvModel = model({ create });
@@ -174,11 +183,6 @@ export function keyval<Input, ModelEnhance, Api, Shape>(
             ? null
             : getKeyRaw
           : kvModel.keyField;
-        const $entities = createStore<KeyvalListState>({
-          items: [],
-          instances: [],
-          keys: [],
-        });
 
         const api = createInstanceApi($entities, kvModel);
         const editApi = createEditApi(
@@ -213,8 +217,8 @@ export function keyval<Input, ModelEnhance, Api, Shape>(
           // @ts-expect-error bad implementation
           __lens: shape,
           __struct: structShape,
-          $items: $entities.map(({ items }) => items),
-          $keys: $entities.map(({ keys }) => keys),
+          $items,
+          $keys,
           __$listState: $entities as any,
           defaultState() {
             return kvModel?.defaultState() ?? (null as any);

packages/core/src/lazy.ts

@@ -15,16 +15,20 @@ type TypeMap = {
   effect: Effect<any, any, any>;
 };
 
-let currentSkipLazyCb = true;
+export let currentSkipLazyCb = true;
+export let isRoot = true;
 
 export function callInLazyStack<T extends () => any>(
   fn: T,
   skipLazyCb: boolean,
 ): ReturnType<T> {
   const prevLazyCb = currentSkipLazyCb;
+  const prevIsRoot = isRoot;
   currentSkipLazyCb = skipLazyCb;
+  isRoot = false;
   const result = fn();
   currentSkipLazyCb = prevLazyCb;
+  isRoot = prevIsRoot;
   return result;
 }
 

packages/core/src/lazyInit.ts

@@ -1,3 +1,5 @@
+import { currentSkipLazyCb, isRoot } from './lazy';
+
 const queue: InitTask<any>[] = [];
 let scheduled = false;
 
@@ -7,7 +9,15 @@ type InitTask<T> = {
   initialized: boolean;
 };
 
-const ignore = ['type', 'clone', 'isClone', 'cloneOf'];
+const ignore = [
+  'type',
+  'clone',
+  'isClone',
+  'cloneOf',
+  '__$listState',
+  '$items',
+  '$keys',
+];
 
 function runQueue() {
   for (const task of queue.splice(0)) {
@@ -29,8 +39,10 @@ function runQueue() {
 }
 
 export function lazyInit<T extends object>(target: T, init: () => T): T {
+  if (currentSkipLazyCb && !isRoot) {
+    return target;
+  }
   const task: InitTask<T> = { target, init, initialized: false };
-
   queue.push(task);
   if (!scheduled) {
     scheduled = true;
@@ -44,7 +56,9 @@ export function lazyInit<T extends object>(target: T, init: () => T): T {
     if (!ignore.includes(key as any)) {
       Object.defineProperty(target, key, {
         get() {
-          if (!task.initialized) runQueue();
+          if (!task.initialized) {
+            runQueue();
+          }
           return target[key];
         },
         enumerable: true,