@craft-ts/core 0.7.0-beta.13

package/src/lib/insert-select.js

@@ -0,0 +1,535 @@
+import { DestroyRef, Injector, inject, isSignal, runInInjectionContext, untracked, } from './host/craft-compat';
+import { takeUntilDestroyed } from './host/craft-compat';
+import { ɵcreateHostTaggedInjector } from './craft-service';
+import { source$ } from './source$';
+import { capitalize, isSource } from './util/util';
+import { INSERTION_SNAPSHOT_REGISTRY, snapshotSelectProxy, } from './take-app-snapshot';
+import { isGenerator, runCraftGenerator } from './craft-generator-runtime';
+import { injectFnWrapper } from './fn-wrapper';
+import { ɵprovidePrimitiveMethodRuntimeContext } from './primitive-method-runtime-context';
+import { createYieldableInsertionMethod, isNonYieldableInsertionMethod, markNonYieldableInsertionMethod, yieldableInvocation, } from './yieldable';
+import { createYieldableReactiveValue, isYieldableReactiveValue, rawReactiveValue, } from './reactive-read';
+import { craftLinkedSignal } from './host/craft-linked-signal';
+function readInsertionState(state) {
+    return isYieldableReactiveValue(state) ? rawReactiveValue(state)() : state();
+}
+function isSource$(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'emit' in value &&
+        typeof value.emit === 'function' &&
+        'subscribe' in value &&
+        typeof value.subscribe === 'function');
+}
+function isFlatCrossLayerEvent(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'payload' in value &&
+        'path' in value &&
+        'leaf' in value &&
+        Array.isArray(value.path) &&
+        typeof value.leaf === 'object' &&
+        value.leaf !== null &&
+        'item' in value.leaf &&
+        'index' in value.leaf);
+}
+const INSERT_SELECT_INVALID_YIELD_ERROR_MESSAGE = 'insertSelect generators can only yield craftService dependencies or exposed dependency helpers.';
+const INSERT_SELECT_APP_START_ERROR_MESSAGE = 'insertSelect generators do not support onAppStart(...).';
+function createInsertSelectItemRuntime(entityName, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+...itemInsertions) {
+    return (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    context) => {
+        const { state, update, insertions: previousInsertions, __primitiveKind: primitiveKind = 'state', } = context;
+        const insertionSnapshotRegistry = inject(INSERTION_SNAPSHOT_REGISTRY, {
+            optional: true,
+        });
+        const injector = ɵcreateHostTaggedInjector(inject(Injector), `selectEntity:${entityName}`, [{ provide: INSERTION_SNAPSHOT_REGISTRY, useValue: null }]);
+        const selectItemMethodName = `select${capitalize(entityName)}`;
+        const selectedStateById = new Map();
+        const inheritedInsertions = previousInsertions ?? {};
+        const select = (id) => {
+            const currentState = readInsertionState(state);
+            if (!Array.isArray(currentState)) {
+                return undefined;
+            }
+            return currentState[id];
+        };
+        const selectItem = (id) => {
+            const cached = selectedStateById.get(id);
+            if (cached) {
+                return cached;
+            }
+            const selectedStateValue = select(id);
+            if (selectedStateValue === undefined) {
+                return undefined;
+            }
+            const selectedStateSignal = craftLinkedSignal({
+                source: () => select(id),
+                computation: (selected) => selected,
+                injector,
+            });
+            const itemInjector = ɵcreateHostTaggedInjector(injector, `selectItem:${id}`);
+            const { rawInsertionsOutput, exposedInsertionsOutput } = itemInsertions.reduce((acc, insertion) => {
+                const wrappedInsertion = runInInjectionContext(itemInjector, () => injectFnWrapper()(insertion));
+                const insertionContext = {
+                    state: createYieldableReactiveValue(selectedStateSignal, 'state', { primitive: 'insertSelect', path: `${name}.state` }),
+                    __primitiveKind: primitiveKind,
+                    set: (newState) => yieldableInvocation((() => {
+                        update((currentState) => {
+                            if (!Array.isArray(currentState)) {
+                                return currentState;
+                            }
+                            if (id < 0 ||
+                                id >= currentState.length ||
+                                !Number.isInteger(id)) {
+                                return currentState;
+                            }
+                            const nextState = [...currentState];
+                            nextState[id] = newState;
+                            return nextState;
+                        });
+                        return newState;
+                    })()),
+                    update: (updateFn) => yieldableInvocation((() => {
+                        const currentSelectedState = select(id);
+                        if (currentSelectedState === undefined) {
+                            return undefined;
+                        }
+                        const nextState = updateFn(currentSelectedState);
+                        update((currentState) => {
+                            if (!Array.isArray(currentState)) {
+                                return currentState;
+                            }
+                            if (id < 0 ||
+                                id >= currentState.length ||
+                                !Number.isInteger(id)) {
+                                return currentState;
+                            }
+                            const nextRootState = [...currentState];
+                            nextRootState[id] = nextState;
+                            return nextRootState;
+                        });
+                        return nextState;
+                    })()),
+                    patch: (patchFn) => yieldableInvocation((() => {
+                        const currentSelectedState = select(id);
+                        if (currentSelectedState === undefined) {
+                            return undefined;
+                        }
+                        const nextState = {
+                            ...currentSelectedState,
+                            ...patchFn(currentSelectedState),
+                        };
+                        update((currentState) => {
+                            if (!Array.isArray(currentState)) {
+                                return currentState;
+                            }
+                            if (id < 0 ||
+                                id >= currentState.length ||
+                                !Number.isInteger(id)) {
+                                return currentState;
+                            }
+                            const nextRootState = [...currentState];
+                            nextRootState[id] = nextState;
+                            return nextRootState;
+                        });
+                        return nextState;
+                    })()),
+                    insertions: Object.entries(acc.rawInsertionsOutput).reduce((previous, [key, value]) => {
+                        if (isSource$(value))
+                            previous[key] = value;
+                        return previous;
+                    }, {
+                        ...inheritedInsertions,
+                        ...acc.exposedInsertionsOutput,
+                    }),
+                };
+                const insertionCallResult = wrappedInsertion(insertionContext);
+                const nextRawInsertions = (isGenerator(insertionCallResult)
+                    ? runInInjectionContext(itemInjector, () => runCraftGenerator({
+                        iterator: insertionCallResult,
+                        injector: itemInjector,
+                        hostScope: 'function',
+                        invalidYieldErrorMessage: INSERT_SELECT_INVALID_YIELD_ERROR_MESSAGE,
+                        multipleAppStartErrorMessage: INSERT_SELECT_APP_START_ERROR_MESSAGE,
+                        onAppStartNotSupportedErrorMessage: INSERT_SELECT_APP_START_ERROR_MESSAGE,
+                    }).value)
+                    : insertionCallResult);
+                const nextExposedInsertions = Object.entries(nextRawInsertions).reduce((exposedAcc, [key, value]) => {
+                    if (isSource(value)) {
+                        return exposedAcc;
+                    }
+                    if (isSource$(value)) {
+                        const localSource = value;
+                        const sourceInjector = ɵcreateHostTaggedInjector(itemInjector, `source:${key}`);
+                        const wrappedEmit = runInInjectionContext(sourceInjector, () => injectFnWrapper()((payload) => localSource.emit(payload)));
+                        exposedAcc[key] = createYieldableInsertionMethod((payload) => wrappedEmit(payload), {
+                            injector: sourceInjector,
+                            invalidYieldErrorMessage: INSERT_SELECT_INVALID_YIELD_ERROR_MESSAGE,
+                            multipleAppStartErrorMessage: INSERT_SELECT_APP_START_ERROR_MESSAGE,
+                            onAppStartNotSupportedErrorMessage: INSERT_SELECT_APP_START_ERROR_MESSAGE,
+                        });
+                        return exposedAcc;
+                    }
+                    if (typeof value === 'function' &&
+                        !isSignal(value) &&
+                        !isYieldableReactiveValue(value) &&
+                        !isNonYieldableInsertionMethod(value)) {
+                        const methodInjector = ɵcreateHostTaggedInjector(itemInjector, `method:${key}`, [
+                            ɵprovidePrimitiveMethodRuntimeContext(primitiveKind, { ...insertionContext, state: selectedStateSignal }, value),
+                        ]);
+                        const wrappedFn = runInInjectionContext(methodInjector, () => injectFnWrapper()(value));
+                        exposedAcc[key] = createYieldableInsertionMethod(wrappedFn, {
+                            injector: methodInjector,
+                            invalidYieldErrorMessage: INSERT_SELECT_INVALID_YIELD_ERROR_MESSAGE,
+                            multipleAppStartErrorMessage: INSERT_SELECT_APP_START_ERROR_MESSAGE,
+                            onAppStartNotSupportedErrorMessage: INSERT_SELECT_APP_START_ERROR_MESSAGE,
+                        });
+                    }
+                    else {
+                        exposedAcc[key] = value;
+                    }
+                    return exposedAcc;
+                }, {});
+                return {
+                    rawInsertionsOutput: {
+                        ...acc.rawInsertionsOutput,
+                        ...nextRawInsertions,
+                    },
+                    exposedInsertionsOutput: {
+                        ...acc.exposedInsertionsOutput,
+                        ...nextExposedInsertions,
+                    },
+                };
+            }, {
+                rawInsertionsOutput: {},
+                exposedInsertionsOutput: {},
+            });
+            const stateProxy = new Proxy(exposedInsertionsOutput, {
+                get(target, property, receiver) {
+                    if (Reflect.has(target, property)) {
+                        return Reflect.get(target, property, receiver);
+                    }
+                    // Read through the per-item signal, NOT `select(id)`.
+                    //
+                    // `select(id)` reads the whole array and then indexes it, so a
+                    // template binding that reached a field this way subscribed to the
+                    // ENTIRE collection: any write to any item re-ran every binding. A
+                    // 16x16 grid spent ~400ms of a single paint re-evaluating all 256
+                    // cells — and re-evaluated them again on changes that touched no
+                    // cell at all.
+                    //
+                    // `selectedStateSignal` recomputes off the same array but keeps its
+                    // previous value when this item is untouched, so it only notifies
+                    // the readers of the item that actually changed.
+                    const stateValue = selectedStateSignal();
+                    if (!stateValue || typeof stateValue !== 'object') {
+                        return undefined;
+                    }
+                    return Reflect.get(stateValue, property);
+                },
+            });
+            selectedStateById.set(id, stateProxy);
+            return stateProxy;
+        };
+        const items = () => {
+            const currentState = readInsertionState(state);
+            if (!Array.isArray(currentState)) {
+                return [];
+            }
+            return currentState.reduce((acc, _unused, index) => {
+                const selectedItem = selectItem(index);
+                if (selectedItem !== undefined) {
+                    acc.push(selectedItem);
+                }
+                return acc;
+            }, []);
+        };
+        const currentState = readInsertionState(state);
+        if (Array.isArray(currentState) && currentState.length > 0) {
+            selectItem(0);
+        }
+        if (insertionSnapshotRegistry) {
+            const destroyRef = inject(DestroyRef);
+            insertionSnapshotRegistry.trigger$
+                .pipe(takeUntilDestroyed(destroyRef))
+                .subscribe(() => {
+                const rawState = readInsertionState(state);
+                if (!Array.isArray(rawState))
+                    return;
+                const snapshot = rawState.map((rawItem, i) => {
+                    const proxy = selectItem(i);
+                    return snapshotSelectProxy(proxy, rawItem);
+                });
+                insertionSnapshotRegistry.allInsertionSnapshot$.next({
+                    key: selectItemMethodName,
+                    value: snapshot,
+                });
+            });
+        }
+        return {
+            [selectItemMethodName]: markNonYieldableInsertionMethod(selectItem),
+            items: markNonYieldableInsertionMethod(items),
+        };
+    };
+}
+function createInsertSelectPropertyRuntime(propertyKey, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+...propertyInsertions) {
+    return (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    context) => {
+        const { state, update, insertions: previousInsertions, __primitiveKind: primitiveKind = 'state', } = context;
+        const insertionSnapshotRegistry = inject(INSERTION_SNAPSHOT_REGISTRY, {
+            optional: true,
+        });
+        const injector = ɵcreateHostTaggedInjector(inject(Injector), `selectProperty:${propertyKey}`, [{ provide: INSERTION_SNAPSHOT_REGISTRY, useValue: null }]);
+        let selectedPropertyProxy;
+        const crossLayerSourcesByKey = new Map();
+        const selectPropertyMethodName = `select${capitalize(propertyKey)}`;
+        const inheritedInsertions = previousInsertions ?? {};
+        const getOrCreateCrossLayerSource = (key) => {
+            const sourceValue = crossLayerSourcesByKey.get(key);
+            if (sourceValue) {
+                return sourceValue;
+            }
+            const newSource = source$(key);
+            crossLayerSourcesByKey.set(key, newSource);
+            return newSource;
+        };
+        const selectProperty = () => {
+            const currentState = readInsertionState(state);
+            if (!currentState || typeof currentState !== 'object') {
+                return undefined;
+            }
+            return currentState[propertyKey];
+        };
+        const setProperty = (newProperty) => {
+            update((currentState) => {
+                if (!currentState || typeof currentState !== 'object') {
+                    return currentState;
+                }
+                return {
+                    ...currentState,
+                    [propertyKey]: newProperty,
+                };
+            });
+            return newProperty;
+        };
+        const updateProperty = (updateFn) => {
+            const nextProperty = updateFn(selectProperty());
+            setProperty(nextProperty);
+            return nextProperty;
+        };
+        const selectPropertyItem = () => {
+            if (selectedPropertyProxy) {
+                return selectedPropertyProxy;
+            }
+            const selectedPropertySignal = craftLinkedSignal({
+                source: selectProperty,
+                computation: (selected) => selected,
+                injector,
+            });
+            const { rawInsertionsOutput, exposedInsertionsOutput } = propertyInsertions.reduce((acc, insertion) => {
+                const wrappedInsertion = runInInjectionContext(injector, () => injectFnWrapper()(insertion));
+                const insertionContext = {
+                    state: createYieldableReactiveValue(selectedPropertySignal, 'state', { primitive: 'insertSelect', path: `${name}.state` }),
+                    __primitiveKind: primitiveKind,
+                    set: (newState) => {
+                        setProperty(newState);
+                        return yieldableInvocation(newState);
+                    },
+                    update: (updateFn) => {
+                        return yieldableInvocation(updateProperty(updateFn));
+                    },
+                    patch: (patchFn) => {
+                        return yieldableInvocation(updateProperty((current) => ({
+                            ...current,
+                            ...patchFn(current),
+                        })));
+                    },
+                    insertions: Object.entries(acc.rawInsertionsOutput).reduce((previous, [key, value]) => {
+                        if (isSource$(value))
+                            previous[key] = value;
+                        return previous;
+                    }, {
+                        ...inheritedInsertions,
+                        ...acc.exposedInsertionsOutput,
+                    }),
+                };
+                const insertionCallResult = wrappedInsertion(insertionContext);
+                const nextRawInsertions = (isGenerator(insertionCallResult)
+                    ? runInInjectionContext(injector, () => runCraftGenerator({
+                        iterator: insertionCallResult,
+                        injector,
+                        hostScope: 'function',
+                        invalidYieldErrorMessage: INSERT_SELECT_INVALID_YIELD_ERROR_MESSAGE,
+                        multipleAppStartErrorMessage: INSERT_SELECT_APP_START_ERROR_MESSAGE,
+                        onAppStartNotSupportedErrorMessage: INSERT_SELECT_APP_START_ERROR_MESSAGE,
+                    }).value)
+                    : insertionCallResult);
+                const nextExposedInsertions = Object.entries(nextRawInsertions).reduce((exposedAcc, [key, value]) => {
+                    if (isSource(value)) {
+                        return exposedAcc;
+                    }
+                    if (isSource$(value)) {
+                        const localSource = value;
+                        const crossLayerSource = getOrCreateCrossLayerSource(key);
+                        localSource.subscribe((payload) => {
+                            const propertyAtEmit = selectProperty();
+                            if (isFlatCrossLayerEvent(payload)) {
+                                crossLayerSource.emit({
+                                    payload: payload.payload,
+                                    path: [propertyKey, ...payload.path],
+                                    leaf: payload.leaf,
+                                });
+                                return;
+                            }
+                            crossLayerSource.emit({
+                                payload,
+                                path: [propertyKey],
+                                leaf: {
+                                    item: propertyAtEmit,
+                                    index: propertyKey,
+                                },
+                            });
+                        });
+                        const sourceInjector = ɵcreateHostTaggedInjector(injector, `source:${key}`);
+                        const wrappedEmit = runInInjectionContext(sourceInjector, () => injectFnWrapper()((payload) => localSource.emit(payload)));
+                        exposedAcc[key] = createYieldableInsertionMethod((payload) => wrappedEmit(payload), {
+                            injector: sourceInjector,
+                            invalidYieldErrorMessage: INSERT_SELECT_INVALID_YIELD_ERROR_MESSAGE,
+                            multipleAppStartErrorMessage: INSERT_SELECT_APP_START_ERROR_MESSAGE,
+                            onAppStartNotSupportedErrorMessage: INSERT_SELECT_APP_START_ERROR_MESSAGE,
+                        });
+                        return exposedAcc;
+                    }
+                    if (typeof value === 'function' &&
+                        !isSignal(value) &&
+                        !isYieldableReactiveValue(value) &&
+                        !isNonYieldableInsertionMethod(value)) {
+                        const methodInjector = ɵcreateHostTaggedInjector(injector, `method:${key}`, [
+                            ɵprovidePrimitiveMethodRuntimeContext(primitiveKind, { ...insertionContext, state: selectedPropertySignal }, value),
+                        ]);
+                        const wrappedFn = runInInjectionContext(methodInjector, () => injectFnWrapper()(value));
+                        exposedAcc[key] = createYieldableInsertionMethod(wrappedFn, {
+                            injector: methodInjector,
+                            invalidYieldErrorMessage: INSERT_SELECT_INVALID_YIELD_ERROR_MESSAGE,
+                            multipleAppStartErrorMessage: INSERT_SELECT_APP_START_ERROR_MESSAGE,
+                            onAppStartNotSupportedErrorMessage: INSERT_SELECT_APP_START_ERROR_MESSAGE,
+                        });
+                    }
+                    else {
+                        exposedAcc[key] = value;
+                    }
+                    return exposedAcc;
+                }, {});
+                return {
+                    rawInsertionsOutput: {
+                        ...acc.rawInsertionsOutput,
+                        ...nextRawInsertions,
+                    },
+                    exposedInsertionsOutput: {
+                        ...acc.exposedInsertionsOutput,
+                        ...nextExposedInsertions,
+                    },
+                };
+            }, {
+                rawInsertionsOutput: {},
+                exposedInsertionsOutput: {},
+            });
+            selectedPropertyProxy = new Proxy(exposedInsertionsOutput, {
+                get(target, property, receiver) {
+                    if (Reflect.has(target, property)) {
+                        return Reflect.get(target, property, receiver);
+                    }
+                    const currentProperty = selectProperty();
+                    if (!currentProperty || typeof currentProperty !== 'object') {
+                        return undefined;
+                    }
+                    return Reflect.get(currentProperty, property);
+                },
+            });
+            return selectedPropertyProxy;
+        };
+        // Ensure cross-layer sources are available for subsequent state insertions.
+        selectPropertyItem();
+        if (insertionSnapshotRegistry) {
+            const destroyRef = inject(DestroyRef);
+            insertionSnapshotRegistry.trigger$
+                .pipe(takeUntilDestroyed(destroyRef))
+                .subscribe(() => {
+                const proxy = selectPropertyItem();
+                const rawPropertyValue = readInsertionState(state);
+                const rawPropValue = rawPropertyValue &&
+                    typeof rawPropertyValue === 'object' &&
+                    propertyKey in rawPropertyValue
+                    ? rawPropertyValue[propertyKey]
+                    : undefined;
+                insertionSnapshotRegistry.allInsertionSnapshot$.next({
+                    key: selectPropertyMethodName,
+                    value: snapshotSelectProxy(proxy, rawPropValue),
+                });
+            });
+        }
+        return {
+            [selectPropertyMethodName]: markNonYieldableInsertionMethod(selectPropertyItem),
+            ...Object.fromEntries(crossLayerSourcesByKey.entries()),
+        };
+    };
+}
+function createDeferredInsertSelectRuntime(entityName, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+...insertions) {
+    return (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    context) => {
+        const selectMethodName = `select${capitalize(entityName)}`;
+        const runtimeInjector = inject(Injector);
+        let activeIsArray;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let activeRuntime;
+        const getActiveRuntime = () => {
+            // Untracked on purpose. Whether the state is an array picks which runtime
+            // to build — a structural question, not a value this selector depends on.
+            // Reading it tracked subscribed EVERY caller to the whole collection, so
+            // a template binding that selected one item re-ran whenever any item
+            // changed, and even when something unrelated did.
+            const isArray = Array.isArray(untracked(() => readInsertionState(context.state)));
+            if (activeRuntime && activeIsArray === isArray) {
+                return activeRuntime;
+            }
+            activeIsArray = isArray;
+            activeRuntime = runInInjectionContext(runtimeInjector, () => isArray
+                ? createInsertSelectItemRuntime(entityName, ...insertions)(context)
+                : createInsertSelectPropertyRuntime(entityName, ...insertions)(context));
+            return activeRuntime;
+        };
+        const select = (...args) => getActiveRuntime()[selectMethodName](...args);
+        return {
+            [selectMethodName]: markNonYieldableInsertionMethod(select),
+            items: markNonYieldableInsertionMethod(() => getActiveRuntime().items?.() ?? []),
+        };
+    };
+}
+export function insertSelect(name, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+...insertions) {
+    return (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    context) => {
+        const currentState = readInsertionState(context.state);
+        if (currentState === undefined &&
+            context.__primitiveKind &&
+            context.__primitiveKind !== 'state') {
+            return createDeferredInsertSelectRuntime(name, ...insertions)(context);
+        }
+        if (Array.isArray(currentState)) {
+            return createInsertSelectItemRuntime(name, ...insertions)(context);
+        }
+        return createInsertSelectPropertyRuntime(name, ...insertions)(context);
+    };
+}
+//# sourceMappingURL=insert-select.js.map