@craft-ts/core 0.7.0-beta.13

package/src/lib/after-recomputation.d.ts

@@ -0,0 +1,327 @@
+import { type Signal } from './host/craft-compat';
+import { SignalSource } from './signal-source';
+import { ReadonlySource } from './util/source.type';
+/**
+ * Creates a derived readonly source that transforms source emissions through a callback function.
+ *
+ * This function binds queries, mutations, and async methods to sources for automatic execution by:
+ * - Listening to source emissions and computing new values
+ * - Providing a readonly source suitable for method binding
+ * - Maintaining reactivity through Angular's effect system
+ * - Enabling source-based triggering patterns
+ *
+ * @remarks
+ * **Primary Use Case:**
+ * Bind queries/mutations/async methods to sources for automatic execution:
+ * ```ts
+ * method: afterRecomputation(mySource, (data) => data)
+ * ```
+ * This pattern makes queries/mutations execute automatically when the source emits.
+ *
+ * **Execution Flow:**
+ * 1. Source emits a value via `source.set(value)`
+ * 2. afterRecomputation callback transforms the value
+ * 3. Resulting readonly source emits the transformed value
+ * 4. Bound query/mutation/async method executes with the new value
+ *
+ * **Difference from computedSource:**
+ * - `afterRecomputation`: Designed for binding to method parameters
+ * - `computedSource`: General-purpose source transformation
+ * - Both transform source values, but afterRecomputation is optimized for method binding
+ *
+ * **Common Patterns:**
+ * - **Identity transformation**: `afterRecomputation(source, (x) => x)` - pass value through
+ * - **Field extraction**: `afterRecomputation(source, (data) => data.id)` - extract specific field
+ * - **Validation**: `afterRecomputation(source, (data) => validate(data))` - transform and validate
+ * - **Mapping**: `afterRecomputation(source, (data) => mapToDto(data))` - convert to different type
+ *
+ * @template State - The type of values produced by the callback
+ * @template SourceType - The type of values emitted by the origin source
+ *
+ * @param _source - The source to listen to.
+ *   When this source emits, the callback is invoked.
+ *
+ * @param callback - Function that transforms source values.
+ *   Receives the emitted value and returns the transformed result.
+ *
+ * @returns A readonly source that emits transformed values.
+ *   Can be used as the `method` parameter in queries, mutations, and async methods.
+ *
+ * @example
+ * Binding a query to a source for automatic execution
+ * ```ts
+ * const { UserStore } = craftService(
+ *   { name: 'UserStore', providedIn: 'toProvide' },
+ *   function* () {
+ *     const userIdChange = signalSource<string>('userIdChange');
+ *
+ *     const user = yield* query({
+ *       method: afterRecomputation(userIdChange, (userId) => userId),
+ *       loader: async ({ params }) => {
+ *         const response = await fetch(`/api/users/${params}`);
+ *         return response.json();
+ *       },
+ *     });
+ *
+ *     return { userIdChange, user };
+ *   },
+ * );
+ *
+ * const store = UserStore();
+ *
+ * // Query executes automatically when source emits
+ * store.userIdChange.set('user-123');
+ * // -> query loader executes with params 'user-123'
+ *
+ * store.userIdChange.set('user-456');
+ * // -> query loader executes again with params 'user-456'
+ * ```
+ *
+ * @example
+ * Binding a mutation to a source
+ * ```ts
+ * const { FormStore } = craftService(
+ *   { name: 'FormStore', providedIn: 'toProvide' },
+ *   function* () {
+ *     const submitForm = signalSource<{ name: string; email: string }>('submitForm');
+ *
+ *     const submit = yield* mutation({
+ *       method: afterRecomputation(submitForm, (formData) => formData),
+ *       loader: async ({ params }) => {
+ *         const response = await fetch('/api/submit', {
+ *           method: 'POST',
+ *           body: JSON.stringify(params),
+ *         });
+ *         return response.json();
+ *       },
+ *     });
+ *
+ *     return { submitForm, submit };
+ *   },
+ * );
+ *
+ * const store = FormStore();
+ *
+ * // Mutation executes automatically when source emits
+ * store.submitForm.set({ name: 'John', email: 'john@example.com' });
+ * // -> mutation loader executes with form data
+ * // The mutation is driven by the source; store.submit.mutate() is unused here
+ * ```
+ *
+ * @example
+ * Binding an async process to a source
+ * ```ts
+ * const { SearchStore } = craftService(
+ *   { name: 'SearchStore', providedIn: 'toProvide' },
+ *   function* () {
+ *     const searchInput = signalSource<string>('searchInput');
+ *
+ *     const search = yield* asyncProcess({
+ *       method: afterRecomputation(searchInput, (term) => term),
+ *       loader: async ({ params }) => {
+ *         // Debounce at source level before setting
+ *         const response = await fetch(`/api/search?q=${params}`);
+ *         return response.json();
+ *       },
+ *     });
+ *
+ *     return { searchInput, search };
+ *   },
+ * );
+ *
+ * const store = SearchStore();
+ *
+ * // Async process executes automatically
+ * store.searchInput.set('query');
+ * // -> search loader executes
+ * ```
+ *
+ * @example
+ * Extracting specific field from complex data
+ * ```ts
+ * type FormData = {
+ *   user: { id: string; name: string };
+ *   address: { city: string };
+ * };
+ *
+ * const { UserFormStore } = craftService(
+ *   { name: 'UserFormStore', providedIn: 'toProvide' },
+ *   function* () {
+ *     const formSubmit = signalSource<FormData>('formSubmit');
+ *
+ *     const updateUser = yield* mutation({
+ *       // Extract only user data
+ *       method: afterRecomputation(formSubmit, (data) => data.user),
+ *       loader: async ({ params }) => {
+ *         const response = await fetch(`/api/users/${params.id}`, {
+ *           method: 'PATCH',
+ *           body: JSON.stringify(params),
+ *         });
+ *         return response.json();
+ *       },
+ *     });
+ *
+ *     return { formSubmit, updateUser };
+ *   },
+ * );
+ *
+ * const store = UserFormStore();
+ *
+ * // Only user data is passed to the mutation
+ * store.formSubmit.set({
+ *   user: { id: 'user-1', name: 'John' },
+ *   address: { city: 'NYC' },
+ * });
+ * // -> mutation receives only { id: 'user-1', name: 'John' }
+ * ```
+ *
+ * @example
+ * Transforming data before execution
+ * ```ts
+ * const { ResultsStore } = craftService(
+ *   { name: 'ResultsStore', providedIn: 'toProvide' },
+ *   function* () {
+ *     const searchParams = signalSource<{ query: string; filters: string[] }>('searchParams');
+ *
+ *     const results = yield* query({
+ *       method: afterRecomputation(searchParams, (params) => ({
+ *         q: params.query.trim().toLowerCase(),
+ *         f: params.filters.join(','),
+ *       })),
+ *       loader: async ({ params }) => {
+ *         const queryString = new URLSearchParams(params);
+ *         const response = await fetch(`/api/search?${queryString}`);
+ *         return response.json();
+ *       },
+ *     });
+ *
+ *     return { searchParams, results };
+ *   },
+ * );
+ *
+ * const store = ResultsStore();
+ *
+ * // Data is transformed before query execution
+ * store.searchParams.set({
+ *   query: '  Angular  ',
+ *   filters: ['tutorial', 'advanced'],
+ * });
+ * // -> query receives { q: 'angular', f: 'tutorial,advanced' }
+ * ```
+ *
+ * @example
+ * Validation and type narrowing
+ * ```ts
+ * const { ValidationStore } = craftService(
+ *   { name: 'ValidationStore', providedIn: 'toProvide' },
+ *   function* () {
+ *     const inputChange = signalSource<string>('inputChange');
+ *
+ *     const validate = yield* asyncProcess({
+ *       method: afterRecomputation(inputChange, (input) => {
+ *         // Only proceed if input is valid
+ *         const trimmed = input.trim();
+ *         if (trimmed.length < 3) {
+ *           throw new Error('Input too short');
+ *         }
+ *         return trimmed;
+ *       }),
+ *       loader: async ({ params }) => {
+ *         const response = await fetch('/api/validate', {
+ *           method: 'POST',
+ *           body: JSON.stringify({ input: params }),
+ *         });
+ *         return response.json();
+ *       },
+ *     });
+ *
+ *     return { inputChange, validate };
+ *   },
+ * );
+ *
+ * const store = ValidationStore();
+ *
+ * // Invalid input throws error in the callback
+ * store.inputChange.set('ab'); // Error: Input too short
+ *
+ * // Valid input proceeds
+ * store.inputChange.set('valid input'); // Validation executes
+ * ```
+ *
+ * @example
+ * Multiple sources with different transformations
+ * ```ts
+ * const { SearchResultsStore } = craftService(
+ *   { name: 'SearchResultsStore', providedIn: 'toProvide' },
+ *   function* () {
+ *     const quickSearch = signalSource<string>('quickSearch');
+ *     const advancedSearch = signalSource<{ query: string; options: unknown }>('advancedSearch');
+ *
+ *     const searchResults = yield* query({
+ *       method: afterRecomputation(
+ *         // Can combine sources at a higher level
+ *         quickSearch, // For this example, using one source
+ *         (term) => ({ query: term, mode: 'quick' }),
+ *       ),
+ *       loader: async ({ params }) => {
+ *         const response = await fetch('/api/search', {
+ *           method: 'POST',
+ *           body: JSON.stringify(params),
+ *         });
+ *         return response.json();
+ *       },
+ *     });
+ *
+ *     return { quickSearch, advancedSearch, searchResults };
+ *   },
+ * );
+ *
+ * const store = SearchResultsStore();
+ *
+ * // Quick search with a simple string
+ * store.quickSearch.set('angular');
+ * // -> query receives { query: 'angular', mode: 'quick' }
+ * ```
+ *
+ * @example
+ * Identity transformation (pass-through)
+ * ```ts
+ * const { DataStore } = craftService(
+ *   { name: 'DataStore', providedIn: 'toProvide' },
+ *   function* () {
+ *     const dataUpdate = signalSource<{ id: string; payload: unknown }>('dataUpdate');
+ *
+ *     const update = yield* mutation({
+ *       // Pass data through unchanged
+ *       method: afterRecomputation(dataUpdate, (data) => data),
+ *       loader: async ({ params }) => {
+ *         const response = await fetch(`/api/data/${params.id}`, {
+ *           method: 'PUT',
+ *           body: JSON.stringify(params.payload),
+ *         });
+ *         return response.json();
+ *       },
+ *     });
+ *
+ *     return { dataUpdate, update };
+ *   },
+ * );
+ *
+ * const store = DataStore();
+ *
+ * // Data passed through unchanged
+ * store.dataUpdate.set({ id: 'item-1', payload: { value: 123 } });
+ * // -> mutation receives the exact same object
+ * ```
+ */
+export declare function afterRecomputation<State, SourceType>(_source: SignalSource<SourceType>, callback: (source: SourceType) => State): ReadonlySource<State>;
+export declare function afterRecomputation<State, SourceType>(_source: ReadonlySource<SourceType>, callback: (source: SourceType) => State): ReadonlySource<State>;
+/**
+ * Inside a `transitionStep(...)`, `afterRecomputation` is a machine
+ * registration: every time the watched value recomputes, the callback runs
+ * untracked with its declaring step restored, so the `transit(...)` attempts it
+ * yields target that step. Consume it with `yield*` so the callback's
+ * dependencies join the machine's dependency graph.
+ */
+export declare function afterRecomputation<Value, Yielded>(source: Signal<Value>, callback: (value: Value) => Generator<Yielded, unknown, unknown>): Generator<Yielded, void, unknown>;
+//# sourceMappingURL=after-recomputation.d.ts.map

package/src/lib/after-recomputation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"after-recomputation.d.ts","sourceRoot":"","sources":["../../../../../libs/core/src/lib/after-recomputation.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7E,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAOpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwTG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,EAClD,OAAO,EAAE,YAAY,CAAC,UAAU,CAAC,EACjC,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,KAAK,GACtC,cAAc,CAAC,KAAK,CAAC,CAAC;AACzB,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,EAClD,OAAO,EAAE,cAAc,CAAC,UAAU,CAAC,EACnC,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,KAAK,GACtC,cAAc,CAAC,KAAK,CAAC,CAAC;AACzB;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAC/C,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,EACrB,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,GAC/D,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC"}

package/src/lib/after-recomputation.js

@@ -0,0 +1,25 @@
+import { effect, signal, untracked } from './host/craft-compat';
+import { SourceBranded } from './util/util';
+import { ɵactiveMachineScope, ɵregisterMachineRecomputation, } from './craft-state-machine-runtime';
+export function afterRecomputation(_source, callback) {
+    if (ɵactiveMachineScope()) {
+        return ɵregisterMachineRecomputation(_source, callback);
+    }
+    const source = _source;
+    const initialValue = source();
+    const derivedSource = signal(initialValue && callback(initialValue));
+    const effectRef = effect(() => {
+        const sourceValue = source();
+        if (sourceValue !== undefined) {
+            untracked(() => {
+                const newState = callback(sourceValue);
+                derivedSource.set(newState);
+            });
+        }
+        else {
+            derivedSource.set(undefined);
+        }
+    }, {});
+    return Object.assign(derivedSource, SourceBranded);
+}
+//# sourceMappingURL=after-recomputation.js.map

package/src/lib/after-recomputation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"after-recomputation.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/after-recomputation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAe,MAAM,qBAAqB,CAAC;AAG7E,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EACL,mBAAmB,EACnB,6BAA6B,GAC9B,MAAM,+BAA+B,CAAC;AA8UvC,MAAM,UAAU,kBAAkB,CAChC,OAGsB,EACtB,QAAuC;IAKvC,IAAI,mBAAmB,EAAE,EAAE,CAAC;QAC1B,OAAO,6BAA6B,CAClC,OAAqC,EACrC,QAAqC,CACF,CAAC;IACxC,CAAC;IAED,MAAM,MAAM,GAAG,OAAqC,CAAC;IACrD,MAAM,YAAY,GAAG,MAAM,EAAE,CAAC;IAC9B,MAAM,aAAa,GAAG,MAAM,CAC1B,YAAY,IAAI,QAAQ,CAAC,YAAY,CAAC,CACvC,CAAC;IACF,MAAM,SAAS,GAAG,MAAM,CAAC,GAAG,EAAE;QAC5B,MAAM,WAAW,GAAG,MAAM,EAAE,CAAC;QAC7B,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC9B,SAAS,CAAC,GAAG,EAAE;gBACb,MAAM,QAAQ,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAC;gBACvC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YAC9B,CAAC,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,aAAa,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC/B,CAAC;IACH,CAAC,EAAE,EAAE,CAAC,CAAC;IACP,OAAO,MAAM,CAAC,MAAM,CAClB,aAAa,EACb,aAAa,CACsB,CAAC;AACxC,CAAC","sourcesContent":["import { effect, signal, untracked, type Signal } from './host/craft-compat';\nimport { SignalSource } from './signal-source';\nimport { ReadonlySource } from './util/source.type';\nimport { SourceBranded } from './util/util';\nimport {\n  ɵactiveMachineScope,\n  ɵregisterMachineRecomputation,\n} from './craft-state-machine-runtime';\n\n/**\n * Creates a derived readonly source that transforms source emissions through a callback function.\n *\n * This function binds queries, mutations, and async methods to sources for automatic execution by:\n * - Listening to source emissions and computing new values\n * - Providing a readonly source suitable for method binding\n * - Maintaining reactivity through Angular's effect system\n * - Enabling source-based triggering patterns\n *\n * @remarks\n * **Primary Use Case:**\n * Bind queries/mutations/async methods to sources for automatic execution:\n * ```ts\n * method: afterRecomputation(mySource, (data) => data)\n * ```\n * This pattern makes queries/mutations execute automatically when the source emits.\n *\n * **Execution Flow:**\n * 1. Source emits a value via `source.set(value)`\n * 2. afterRecomputation callback transforms the value\n * 3. Resulting readonly source emits the transformed value\n * 4. Bound query/mutation/async method executes with the new value\n *\n * **Difference from computedSource:**\n * - `afterRecomputation`: Designed for binding to method parameters\n * - `computedSource`: General-purpose source transformation\n * - Both transform source values, but afterRecomputation is optimized for method binding\n *\n * **Common Patterns:**\n * - **Identity transformation**: `afterRecomputation(source, (x) => x)` - pass value through\n * - **Field extraction**: `afterRecomputation(source, (data) => data.id)` - extract specific field\n * - **Validation**: `afterRecomputation(source, (data) => validate(data))` - transform and validate\n * - **Mapping**: `afterRecomputation(source, (data) => mapToDto(data))` - convert to different type\n *\n * @template State - The type of values produced by the callback\n * @template SourceType - The type of values emitted by the origin source\n *\n * @param _source - The source to listen to.\n *   When this source emits, the callback is invoked.\n *\n * @param callback - Function that transforms source values.\n *   Receives the emitted value and returns the transformed result.\n *\n * @returns A readonly source that emits transformed values.\n *   Can be used as the `method` parameter in queries, mutations, and async methods.\n *\n * @example\n * Binding a query to a source for automatic execution\n * ```ts\n * const { UserStore } = craftService(\n *   { name: 'UserStore', providedIn: 'toProvide' },\n *   function* () {\n *     const userIdChange = signalSource<string>('userIdChange');\n *\n *     const user = yield* query({\n *       method: afterRecomputation(userIdChange, (userId) => userId),\n *       loader: async ({ params }) => {\n *         const response = await fetch(`/api/users/${params}`);\n *         return response.json();\n *       },\n *     });\n *\n *     return { userIdChange, user };\n *   },\n * );\n *\n * const store = UserStore();\n *\n * // Query executes automatically when source emits\n * store.userIdChange.set('user-123');\n * // -> query loader executes with params 'user-123'\n *\n * store.userIdChange.set('user-456');\n * // -> query loader executes again with params 'user-456'\n * ```\n *\n * @example\n * Binding a mutation to a source\n * ```ts\n * const { FormStore } = craftService(\n *   { name: 'FormStore', providedIn: 'toProvide' },\n *   function* () {\n *     const submitForm = signalSource<{ name: string; email: string }>('submitForm');\n *\n *     const submit = yield* mutation({\n *       method: afterRecomputation(submitForm, (formData) => formData),\n *       loader: async ({ params }) => {\n *         const response = await fetch('/api/submit', {\n *           method: 'POST',\n *           body: JSON.stringify(params),\n *         });\n *         return response.json();\n *       },\n *     });\n *\n *     return { submitForm, submit };\n *   },\n * );\n *\n * const store = FormStore();\n *\n * // Mutation executes automatically when source emits\n * store.submitForm.set({ name: 'John', email: 'john@example.com' });\n * // -> mutation loader executes with form data\n * // The mutation is driven by the source; store.submit.mutate() is unused here\n * ```\n *\n * @example\n * Binding an async process to a source\n * ```ts\n * const { SearchStore } = craftService(\n *   { name: 'SearchStore', providedIn: 'toProvide' },\n *   function* () {\n *     const searchInput = signalSource<string>('searchInput');\n *\n *     const search = yield* asyncProcess({\n *       method: afterRecomputation(searchInput, (term) => term),\n *       loader: async ({ params }) => {\n *         // Debounce at source level before setting\n *         const response = await fetch(`/api/search?q=${params}`);\n *         return response.json();\n *       },\n *     });\n *\n *     return { searchInput, search };\n *   },\n * );\n *\n * const store = SearchStore();\n *\n * // Async process executes automatically\n * store.searchInput.set('query');\n * // -> search loader executes\n * ```\n *\n * @example\n * Extracting specific field from complex data\n * ```ts\n * type FormData = {\n *   user: { id: string; name: string };\n *   address: { city: string };\n * };\n *\n * const { UserFormStore } = craftService(\n *   { name: 'UserFormStore', providedIn: 'toProvide' },\n *   function* () {\n *     const formSubmit = signalSource<FormData>('formSubmit');\n *\n *     const updateUser = yield* mutation({\n *       // Extract only user data\n *       method: afterRecomputation(formSubmit, (data) => data.user),\n *       loader: async ({ params }) => {\n *         const response = await fetch(`/api/users/${params.id}`, {\n *           method: 'PATCH',\n *           body: JSON.stringify(params),\n *         });\n *         return response.json();\n *       },\n *     });\n *\n *     return { formSubmit, updateUser };\n *   },\n * );\n *\n * const store = UserFormStore();\n *\n * // Only user data is passed to the mutation\n * store.formSubmit.set({\n *   user: { id: 'user-1', name: 'John' },\n *   address: { city: 'NYC' },\n * });\n * // -> mutation receives only { id: 'user-1', name: 'John' }\n * ```\n *\n * @example\n * Transforming data before execution\n * ```ts\n * const { ResultsStore } = craftService(\n *   { name: 'ResultsStore', providedIn: 'toProvide' },\n *   function* () {\n *     const searchParams = signalSource<{ query: string; filters: string[] }>('searchParams');\n *\n *     const results = yield* query({\n *       method: afterRecomputation(searchParams, (params) => ({\n *         q: params.query.trim().toLowerCase(),\n *         f: params.filters.join(','),\n *       })),\n *       loader: async ({ params }) => {\n *         const queryString = new URLSearchParams(params);\n *         const response = await fetch(`/api/search?${queryString}`);\n *         return response.json();\n *       },\n *     });\n *\n *     return { searchParams, results };\n *   },\n * );\n *\n * const store = ResultsStore();\n *\n * // Data is transformed before query execution\n * store.searchParams.set({\n *   query: '  Angular  ',\n *   filters: ['tutorial', 'advanced'],\n * });\n * // -> query receives { q: 'angular', f: 'tutorial,advanced' }\n * ```\n *\n * @example\n * Validation and type narrowing\n * ```ts\n * const { ValidationStore } = craftService(\n *   { name: 'ValidationStore', providedIn: 'toProvide' },\n *   function* () {\n *     const inputChange = signalSource<string>('inputChange');\n *\n *     const validate = yield* asyncProcess({\n *       method: afterRecomputation(inputChange, (input) => {\n *         // Only proceed if input is valid\n *         const trimmed = input.trim();\n *         if (trimmed.length < 3) {\n *           throw new Error('Input too short');\n *         }\n *         return trimmed;\n *       }),\n *       loader: async ({ params }) => {\n *         const response = await fetch('/api/validate', {\n *           method: 'POST',\n *           body: JSON.stringify({ input: params }),\n *         });\n *         return response.json();\n *       },\n *     });\n *\n *     return { inputChange, validate };\n *   },\n * );\n *\n * const store = ValidationStore();\n *\n * // Invalid input throws error in the callback\n * store.inputChange.set('ab'); // Error: Input too short\n *\n * // Valid input proceeds\n * store.inputChange.set('valid input'); // Validation executes\n * ```\n *\n * @example\n * Multiple sources with different transformations\n * ```ts\n * const { SearchResultsStore } = craftService(\n *   { name: 'SearchResultsStore', providedIn: 'toProvide' },\n *   function* () {\n *     const quickSearch = signalSource<string>('quickSearch');\n *     const advancedSearch = signalSource<{ query: string; options: unknown }>('advancedSearch');\n *\n *     const searchResults = yield* query({\n *       method: afterRecomputation(\n *         // Can combine sources at a higher level\n *         quickSearch, // For this example, using one source\n *         (term) => ({ query: term, mode: 'quick' }),\n *       ),\n *       loader: async ({ params }) => {\n *         const response = await fetch('/api/search', {\n *           method: 'POST',\n *           body: JSON.stringify(params),\n *         });\n *         return response.json();\n *       },\n *     });\n *\n *     return { quickSearch, advancedSearch, searchResults };\n *   },\n * );\n *\n * const store = SearchResultsStore();\n *\n * // Quick search with a simple string\n * store.quickSearch.set('angular');\n * // -> query receives { query: 'angular', mode: 'quick' }\n * ```\n *\n * @example\n * Identity transformation (pass-through)\n * ```ts\n * const { DataStore } = craftService(\n *   { name: 'DataStore', providedIn: 'toProvide' },\n *   function* () {\n *     const dataUpdate = signalSource<{ id: string; payload: unknown }>('dataUpdate');\n *\n *     const update = yield* mutation({\n *       // Pass data through unchanged\n *       method: afterRecomputation(dataUpdate, (data) => data),\n *       loader: async ({ params }) => {\n *         const response = await fetch(`/api/data/${params.id}`, {\n *           method: 'PUT',\n *           body: JSON.stringify(params.payload),\n *         });\n *         return response.json();\n *       },\n *     });\n *\n *     return { dataUpdate, update };\n *   },\n * );\n *\n * const store = DataStore();\n *\n * // Data passed through unchanged\n * store.dataUpdate.set({ id: 'item-1', payload: { value: 123 } });\n * // -> mutation receives the exact same object\n * ```\n */\nexport function afterRecomputation<State, SourceType>(\n  _source: SignalSource<SourceType>,\n  callback: (source: SourceType) => State,\n): ReadonlySource<State>;\nexport function afterRecomputation<State, SourceType>(\n  _source: ReadonlySource<SourceType>,\n  callback: (source: SourceType) => State,\n): ReadonlySource<State>;\n/**\n * Inside a `transitionStep(...)`, `afterRecomputation` is a machine\n * registration: every time the watched value recomputes, the callback runs\n * untracked with its declaring step restored, so the `transit(...)` attempts it\n * yields target that step. Consume it with `yield*` so the callback's\n * dependencies join the machine's dependency graph.\n */\nexport function afterRecomputation<Value, Yielded>(\n  source: Signal<Value>,\n  callback: (value: Value) => Generator<Yielded, unknown, unknown>,\n): Generator<Yielded, void, unknown>;\nexport function afterRecomputation<State, SourceType>(\n  _source:\n    | SignalSource<SourceType>\n    | ReadonlySource<SourceType>\n    | Signal<SourceType>,\n  callback: (source: SourceType) => State,\n  // The machine overload resolves to a registration generator instead of a\n  // readonly source, so the implementation signature stays deliberately loose.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n): any {\n  if (ɵactiveMachineScope()) {\n    return ɵregisterMachineRecomputation(\n      _source as unknown as Signal<unknown>,\n      callback as (value: never) => unknown,\n    ) as unknown as ReadonlySource<State>;\n  }\n\n  const source = _source as ReadonlySource<SourceType>;\n  const initialValue = source();\n  const derivedSource = signal<State | undefined>(\n    initialValue && callback(initialValue),\n  );\n  const effectRef = effect(() => {\n    const sourceValue = source();\n    if (sourceValue !== undefined) {\n      untracked(() => {\n        const newState = callback(sourceValue);\n        derivedSource.set(newState);\n      });\n    } else {\n      derivedSource.set(undefined);\n    }\n  }, {});\n  return Object.assign(\n    derivedSource,\n    SourceBranded,\n  ) as unknown as ReadonlySource<State>;\n}\n"]}

package/src/lib/app-checked-di.d.ts

@@ -0,0 +1,82 @@
+import type { Simplify, UnionToTuple } from './craft-service.shared';
+import type { MissingProvidersFromDepsMap } from './branded-component/branded-component';
+import type { AppConfigProvidedDependencyValuesKey, AppConfigProvidedServiceNamesKey } from './craft-app-config';
+type DepsMap<Input> = Input extends {
+    deps: infer Deps extends object;
+} ? Deps : {};
+type ProvidedMap<Input> = Input extends {
+    provided: infer Provided extends object;
+} ? Provided : {};
+type PublicPropertiesMap<Input> = Input extends {
+    publicProperties: infer PublicProperties extends object;
+} ? PublicProperties : {};
+type MissingProviderMap<Input> = Input extends {
+    missingProvider: infer MissingProvider extends object;
+} ? MissingProvider : Simplify<Omit<MissingProvidersFromDepsMap<DepsMap<Input>>, keyof ProvidedMap<Input>>>;
+type AppProvidedServiceNames<Routes> = Routes extends {
+    readonly [Key in AppConfigProvidedServiceNamesKey]?: infer ProvidedNames extends string;
+} ? ProvidedNames : never;
+type AppProvidedDependencyValues<Routes> = Routes extends {
+    readonly [Key in AppConfigProvidedDependencyValuesKey]?: infer ProvidedValues;
+} ? ProvidedValues : never;
+type AppProvidedValueKeys<MissingProviders extends object, ProvidedValues> = {
+    [Name in Extract<keyof MissingProviders, string>]: MissingProviders[Name] extends ProvidedValues ? Name : never;
+}[Extract<keyof MissingProviders, string>];
+type AppMissingProviderMap<AppComponentDeps, AppRoutes extends readonly unknown[]> = Simplify<Omit<MissingProviderMap<AppComponentDeps>, AppProvidedServiceNames<AppRoutes> | AppProvidedValueKeys<MissingProviderMap<AppComponentDeps>, AppProvidedDependencyValues<AppRoutes>>>>;
+type InputErrorMessage<Name extends string, Context extends string> = `Input "${Name}" is not provided in ${Context}`;
+type InjectedErrorMessage<Name extends string, Context extends string> = `The ${Name} service is not provided in ${Context}`;
+type InputErrorMessagesFromNames<Names extends readonly unknown[], Context extends string> = Names extends readonly [infer Head extends string, ...infer Tail] ? [
+    InputErrorMessage<Head, Context>,
+    ...InputErrorMessagesFromNames<Tail, Context>
+] : [];
+type InjectedErrorMessagesFromNames<Names extends readonly unknown[], Context extends string> = Names extends readonly [infer Head extends string, ...infer Tail] ? [
+    InjectedErrorMessage<Head, Context>,
+    ...InjectedErrorMessagesFromNames<Tail, Context>
+] : [];
+type InputErrorMessages<Input, Context extends string> = InputErrorMessagesFromNames<UnionToTuple<Extract<keyof PublicPropertiesMap<Input>, string>>, Context>;
+type InjectedErrorMessages<Input, Context extends string> = InjectedErrorMessagesFromNames<UnionToTuple<Extract<keyof MissingProviderMap<Input>, string>>, Context>;
+type RoutePath<RouteDefinition> = RouteDefinition extends {
+    path: infer Path extends string;
+} ? Path : string;
+type RouteContext<RouteDefinition> = `path: "${RoutePath<RouteDefinition>}"`;
+type RouteErrorMessages<RouteDefinition> = [
+    ...InputErrorMessages<RouteDefinition, RouteContext<RouteDefinition>>,
+    ...InjectedErrorMessages<RouteDefinition, RouteContext<RouteDefinition>>
+];
+type RoutesErrorMessagesByIndex<Routes extends readonly unknown[], Traversed extends readonly unknown[] = readonly []> = number extends Routes['length'] ? UnionToTuple<RouteErrorMessages<Routes[number]>[number]> : Traversed['length'] extends Routes['length'] ? [] : [...Traversed, unknown]['length'] extends Routes['length'] ? [...RouteErrorMessages<Routes[Traversed['length']]>] : [...Traversed, unknown, unknown]['length'] extends Routes['length'] ? [
+    ...RouteErrorMessages<Routes[Traversed['length']]>,
+    ...RouteErrorMessages<Routes[[...Traversed, unknown]['length']]>
+] : [
+    ...Traversed,
+    unknown,
+    unknown,
+    unknown
+]['length'] extends Routes['length'] ? [
+    ...RouteErrorMessages<Routes[Traversed['length']]>,
+    ...RouteErrorMessages<Routes[[...Traversed, unknown]['length']]>,
+    ...RouteErrorMessages<Routes[[...Traversed, unknown, unknown]['length']]>
+] : [
+    ...RouteErrorMessages<Routes[Traversed['length']]>,
+    ...RouteErrorMessages<Routes[[...Traversed, unknown]['length']]>,
+    ...RouteErrorMessages<Routes[[...Traversed, unknown, unknown]['length']]>,
+    ...RouteErrorMessages<Routes[[...Traversed, unknown, unknown, unknown]['length']]>,
+    ...RoutesErrorMessagesByIndex<Routes, [
+        ...Traversed,
+        unknown,
+        unknown,
+        unknown,
+        unknown
+    ]>
+];
+type RoutesErrorMessages<Routes extends readonly unknown[]> = RoutesErrorMessagesByIndex<Routes>;
+type AppErrorMessages<AppComponentDeps, AppRoutes extends readonly unknown[]> = [
+    ...InputErrorMessages<AppComponentDeps, 'AppComponent'>,
+    ...InjectedErrorMessagesFromNames<UnionToTuple<Extract<keyof AppMissingProviderMap<AppComponentDeps, AppRoutes>, string>>, 'AppComponent'>
+];
+export type AppCheckedDI<AppComponentDeps, AppRoutes extends readonly unknown[]> = [
+    ...AppErrorMessages<AppComponentDeps, AppRoutes>,
+    ...RoutesErrorMessages<AppRoutes>
+] extends infer Errors extends string[] ? Errors extends [] ? true : Errors : never;
+export type CanRun<IsAppValid extends true> = IsAppValid extends true ? true : never;
+export {};
+//# sourceMappingURL=app-checked-di.d.ts.map

package/src/lib/app-checked-di.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-checked-di.d.ts","sourceRoot":"","sources":["../../../../../libs/core/src/lib/app-checked-di.ts"],"names":[],"mappings":"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"}

package/src/lib/app-checked-di.js

@@ -0,0 +1 @@
+//# sourceMappingURL=app-checked-di.js.map

package/src/lib/app-checked-di.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-checked-di.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/app-checked-di.ts"],"names":[],"mappings":"","sourcesContent":["import type { Simplify, UnionToTuple } from './craft-service.shared';\nimport type { MissingProvidersFromDepsMap } from './branded-component/branded-component';\nimport type {\n  AppConfigProvidedDependencyValuesKey,\n  AppConfigProvidedServiceNamesKey,\n} from './craft-app-config';\n\ntype DepsMap<Input> = Input extends { deps: infer Deps extends object }\n  ? Deps\n  : {};\n\ntype ProvidedMap<Input> = Input extends {\n  provided: infer Provided extends object;\n}\n  ? Provided\n  : {};\n\ntype PublicPropertiesMap<Input> = Input extends {\n  publicProperties: infer PublicProperties extends object;\n}\n  ? PublicProperties\n  : {};\n\ntype MissingProviderMap<Input> = Input extends {\n  missingProvider: infer MissingProvider extends object;\n}\n  ? MissingProvider\n  : Simplify<\n      Omit<\n        MissingProvidersFromDepsMap<DepsMap<Input>>,\n        keyof ProvidedMap<Input>\n      >\n    >;\n\ntype AppProvidedServiceNames<Routes> = Routes extends {\n  readonly [Key in AppConfigProvidedServiceNamesKey]?: infer ProvidedNames extends\n    string;\n}\n  ? ProvidedNames\n  : never;\n\ntype AppProvidedDependencyValues<Routes> = Routes extends {\n  readonly [Key in AppConfigProvidedDependencyValuesKey]?: infer ProvidedValues;\n}\n  ? ProvidedValues\n  : never;\n\ntype AppProvidedValueKeys<MissingProviders extends object, ProvidedValues> = {\n  [Name in Extract<\n    keyof MissingProviders,\n    string\n  >]: MissingProviders[Name] extends ProvidedValues ? Name : never;\n}[Extract<keyof MissingProviders, string>];\n\ntype AppMissingProviderMap<\n  AppComponentDeps,\n  AppRoutes extends readonly unknown[],\n> = Simplify<\n  Omit<\n    MissingProviderMap<AppComponentDeps>,\n    | AppProvidedServiceNames<AppRoutes>\n    | AppProvidedValueKeys<\n        MissingProviderMap<AppComponentDeps>,\n        AppProvidedDependencyValues<AppRoutes>\n      >\n  >\n>;\n\ntype InputErrorMessage<\n  Name extends string,\n  Context extends string,\n> = `Input \"${Name}\" is not provided in ${Context}`;\n\ntype InjectedErrorMessage<\n  Name extends string,\n  Context extends string,\n> = `The ${Name} service is not provided in ${Context}`;\n\ntype InputErrorMessagesFromNames<\n  Names extends readonly unknown[],\n  Context extends string,\n> = Names extends readonly [infer Head extends string, ...infer Tail]\n  ? [\n      InputErrorMessage<Head, Context>,\n      ...InputErrorMessagesFromNames<Tail, Context>,\n    ]\n  : [];\n\ntype InjectedErrorMessagesFromNames<\n  Names extends readonly unknown[],\n  Context extends string,\n> = Names extends readonly [infer Head extends string, ...infer Tail]\n  ? [\n      InjectedErrorMessage<Head, Context>,\n      ...InjectedErrorMessagesFromNames<Tail, Context>,\n    ]\n  : [];\n\ntype InputErrorMessages<\n  Input,\n  Context extends string,\n> = InputErrorMessagesFromNames<\n  UnionToTuple<Extract<keyof PublicPropertiesMap<Input>, string>>,\n  Context\n>;\n\ntype InjectedErrorMessages<\n  Input,\n  Context extends string,\n> = InjectedErrorMessagesFromNames<\n  UnionToTuple<Extract<keyof MissingProviderMap<Input>, string>>,\n  Context\n>;\n\ntype RoutePath<RouteDefinition> = RouteDefinition extends {\n  path: infer Path extends string;\n}\n  ? Path\n  : string;\n\ntype RouteContext<RouteDefinition> = `path: \"${RoutePath<RouteDefinition>}\"`;\n\ntype RouteErrorMessages<RouteDefinition> = [\n  ...InputErrorMessages<RouteDefinition, RouteContext<RouteDefinition>>,\n  ...InjectedErrorMessages<RouteDefinition, RouteContext<RouteDefinition>>,\n];\n\n// Uses index-based access (works with mapped types like APP_CONFIG_META_DATA) and\n// processes 4 routes per step to keep recursion depth ~N/4 for large route tables.\ntype RoutesErrorMessagesByIndex<\n  Routes extends readonly unknown[],\n  Traversed extends readonly unknown[] = readonly [],\n> = number extends Routes['length']\n  ? UnionToTuple<RouteErrorMessages<Routes[number]>[number]>\n  : Traversed['length'] extends Routes['length']\n    ? []\n    : [...Traversed, unknown]['length'] extends Routes['length']\n      ? [...RouteErrorMessages<Routes[Traversed['length']]>]\n      : [...Traversed, unknown, unknown]['length'] extends Routes['length']\n        ? [\n            ...RouteErrorMessages<Routes[Traversed['length']]>,\n            ...RouteErrorMessages<Routes[[...Traversed, unknown]['length']]>,\n          ]\n        : [\n              ...Traversed,\n              unknown,\n              unknown,\n              unknown,\n            ]['length'] extends Routes['length']\n          ? [\n              ...RouteErrorMessages<Routes[Traversed['length']]>,\n              ...RouteErrorMessages<Routes[[...Traversed, unknown]['length']]>,\n              ...RouteErrorMessages<\n                Routes[[...Traversed, unknown, unknown]['length']]\n              >,\n            ]\n          : [\n              ...RouteErrorMessages<Routes[Traversed['length']]>,\n              ...RouteErrorMessages<Routes[[...Traversed, unknown]['length']]>,\n              ...RouteErrorMessages<\n                Routes[[...Traversed, unknown, unknown]['length']]\n              >,\n              ...RouteErrorMessages<\n                Routes[[...Traversed, unknown, unknown, unknown]['length']]\n              >,\n              ...RoutesErrorMessagesByIndex<\n                Routes,\n                [...Traversed, unknown, unknown, unknown, unknown]\n              >,\n            ];\n\ntype RoutesErrorMessages<Routes extends readonly unknown[]> =\n  RoutesErrorMessagesByIndex<Routes>;\n\ntype AppErrorMessages<\n  AppComponentDeps,\n  AppRoutes extends readonly unknown[],\n> = [\n  ...InputErrorMessages<AppComponentDeps, 'AppComponent'>,\n  ...InjectedErrorMessagesFromNames<\n    UnionToTuple<\n      Extract<keyof AppMissingProviderMap<AppComponentDeps, AppRoutes>, string>\n    >,\n    'AppComponent'\n  >,\n];\n\nexport type AppCheckedDI<\n  AppComponentDeps,\n  AppRoutes extends readonly unknown[],\n> = [\n  ...AppErrorMessages<AppComponentDeps, AppRoutes>,\n  ...RoutesErrorMessages<AppRoutes>,\n] extends infer Errors extends string[]\n  ? Errors extends []\n    ? true\n    : Errors\n  : never;\n\nexport type CanRun<IsAppValid extends true> = IsAppValid extends true\n  ? true\n  : never;\n"]}