@craft-ts/core 0.7.0-beta.13

package/src/lib/computed-source.d.ts

@@ -0,0 +1,303 @@
+import { ValueEqualityFn } from './host/craft-compat';
+import { ReadonlySource } from './util/source.type';
+import { SignalSource } from './signal-source';
+/**
+ * Creates a derived readonly source that transforms values from an origin source using a computation function.
+ *
+ * This function enables reactive transformations of source emissions by:
+ * - Computing new values whenever the origin source emits
+ * - Maintaining source semantics (emits only when explicitly set, not on first read)
+ * - Supporting custom equality comparisons for memoization
+ * - Providing both standard and value-preserving listeners
+ * - Creating composable source pipelines
+ *
+ * @remarks
+ * **Emission Behavior:**
+ * - Only emits when the origin source emits (explicit set/update)
+ * - First read returns `undefined` by default (maintains source semantics)
+ * - Use `preserveLastValue` variant to get computed value on first read
+ *
+ * **Use Cases:**
+ * - **Data transformation**: Convert source payloads to different shapes
+ * - **Filtering**: Extract specific fields from complex source data
+ * - **Formatting**: Apply formatting logic to source values
+ * - **Type narrowing**: Cast or validate source data types
+ * - **Composition**: Chain multiple source transformations
+ * - **Business logic**: Apply domain-specific computations
+ *
+ * **Source vs Signal:**
+ * - Sources emit only on explicit events (set/update calls)
+ * - Signals recompute on every access when dependencies change
+ * - computedSource maintains source lazy behavior
+ *
+ * **Equality Comparison:**
+ * - Default: Uses Angular's default equality check
+ * - Custom: Provide `equal` option for custom comparison
+ * - Prevents unnecessary emissions when computed value hasn't changed
+ *
+ * @template SourceState - The type of values emitted by the origin source
+ * @template ComputedValue - The type of values produced by the computation
+ *
+ * @param signalOrigin - The source or readonly source to derive from.
+ *   Values emitted by this source are passed to the computation function.
+ *
+ * @param computedFn - Function that transforms source values to computed values.
+ *   Called each time the origin source emits.
+ *
+ * @param options - Optional configuration:
+ *   - `equal`: Custom equality function for computed values
+ *   - `debugName`: Name for debugging purposes
+ *
+ * @returns A readonly source that emits computed values with:
+ *   - Standard behavior: First read returns `undefined`, subsequent reads return computed value after source emits
+ *   - `preserveLastValue` property: Returns computed value immediately on first read if source has emitted
+ *
+ * @example
+ * Basic transformation of source data
+ * ```ts
+ * const userSource = source<{ firstName: string; lastName: string }>();
+ *
+ * // Compute full name from user data
+ * const fullNameSource = computedSource(
+ *   userSource,
+ *   (user) => `${user.firstName} ${user.lastName}`
+ * );
+ *
+ * // Use in async method or query
+ * const greetUser = craftUse(asyncProcess({
+ *   method: afterRecomputation(fullNameSource, (fullName) => fullName),
+ *   loader: async ({ params }) => {
+ *     return `Hello, ${params}!`;
+ *   },
+ * }));
+ *
+ * // Trigger chain
+ * userSource.set({ firstName: 'John', lastName: 'Doe' });
+ * // -> fullNameSource emits 'John Doe'
+ * // -> greetUser executes with 'John Doe'
+ * ```
+ *
+ * @example
+ * Extracting specific fields from complex data
+ * ```ts
+ * type FormData = {
+ *   personal: { name: string; email: string };
+ *   address: { street: string; city: string };
+ *   preferences: { newsletter: boolean };
+ * };
+ *
+ * const formSource = source<FormData>();
+ *
+ * // Extract only email for validation
+ * const emailSource = computedSource(
+ *   formSource,
+ *   (form) => form.personal.email
+ * );
+ *
+ * // Extract only address for geocoding
+ * const addressSource = computedSource(
+ *   formSource,
+ *   (form) => form.address
+ * );
+ *
+ * // Use extracted sources
+ * const validateEmail = craftUse(asyncProcess({
+ *   method: afterRecomputation(emailSource, (email) => email),
+ *   loader: async ({ params }) => {
+ *     const response = await fetch('/api/validate-email', {
+ *       method: 'POST',
+ *       body: JSON.stringify({ email: params }),
+ *     });
+ *     return response.json();
+ *   },
+ * }));
+ *
+ * // Update form triggers both validations
+ * formSource.set({
+ *   personal: { name: 'John', email: 'john@example.com' },
+ *   address: { street: '123 Main St', city: 'NYC' },
+ *   preferences: { newsletter: true },
+ * });
+ * ```
+ *
+ * @example
+ * Chaining computed sources for multi-step transformation
+ * ```ts
+ * const inputSource = source<string>();
+ *
+ * // Step 1: Trim and lowercase
+ * const normalizedSource = computedSource(
+ *   inputSource,
+ *   (input) => input.trim().toLowerCase()
+ * );
+ *
+ * // Step 2: Extract search terms
+ * const searchTermsSource = computedSource(
+ *   normalizedSource,
+ *   (normalized) => normalized.split(' ').filter(term => term.length > 0)
+ * );
+ *
+ * // Step 3: Create search query
+ * const searchQuerySource = computedSource(
+ *   searchTermsSource,
+ *   (terms) => ({ terms, operator: 'AND' as const })
+ * );
+ *
+ * // Final async method uses fully transformed data
+ * const search = craftUse(asyncProcess({
+ *   method: afterRecomputation(searchQuerySource, (query) => query),
+ *   loader: async ({ params }) => {
+ *     const response = await fetch('/api/search', {
+ *       method: 'POST',
+ *       body: JSON.stringify(params),
+ *     });
+ *     return response.json();
+ *   },
+ * }));
+ *
+ * // Single input triggers entire chain
+ * inputSource.set('  Angular  Signals  ');
+ * // -> normalizedSource emits 'angular signals'
+ * // -> searchTermsSource emits ['angular', 'signals']
+ * // -> searchQuerySource emits { terms: ['angular', 'signals'], operator: 'AND' }
+ * // -> search executes
+ * ```
+ *
+ * @example
+ * Custom equality comparison
+ * ```ts
+ * type SearchParams = { query: string; timestamp: number };
+ *
+ * const searchSource = source<SearchParams>();
+ *
+ * // Only emit when query changes, ignore timestamp
+ * const queryOnlySource = computedSource(
+ *   searchSource,
+ *   (params) => params.query,
+ *   {
+ *     equal: (a, b) => a === b, // Compare strings
+ *   }
+ * );
+ *
+ * // Update with same query but different timestamp
+ * searchSource.set({ query: 'test', timestamp: Date.now() });
+ * // -> queryOnlySource emits 'test'
+ *
+ * searchSource.set({ query: 'test', timestamp: Date.now() });
+ * // -> queryOnlySource does NOT emit (same query)
+ *
+ * searchSource.set({ query: 'new', timestamp: Date.now() });
+ * // -> queryOnlySource emits 'new'
+ * ```
+ *
+ * @example
+ * Type narrowing and validation
+ * ```ts
+ * type ApiResponse =
+ *   | { type: 'success'; data: unknown }
+ *   | { type: 'error'; message: string };
+ *
+ * const responseSource = source<ApiResponse>();
+ *
+ * // Extract only successful data
+ * const successDataSource = computedSource(
+ *   responseSource,
+ *   (response) => {
+ *     if (response.type === 'success') {
+ *       return response.data;
+ *     }
+ *     return null;
+ *   }
+ * );
+ *
+ * // Extract only errors
+ * const errorSource = computedSource(
+ *   responseSource,
+ *   (response) => {
+ *     if (response.type === 'error') {
+ *       return response.message;
+ *     }
+ *     return null;
+ *   }
+ * );
+ *
+ * // Handle success and errors separately
+ * const Processuccess = craftUse(asyncProcess({
+ *   method: afterRecomputation(successDataSource, (data) => data),
+ *   loader: async ({ params }) => {
+ *     if (!params) return null;
+ *     // Process successful data
+ *     return processData(params);
+ *   },
+ * }));
+ *
+ * const logError = craftUse(asyncProcess({
+ *   method: afterRecomputation(errorSource, (error) => error),
+ *   loader: async ({ params }) => {
+ *     if (!params) return null;
+ *     // Log error
+ *     await logToService(params);
+ *     return { logged: true };
+ *   },
+ * }));
+ * ```
+ *
+ * @example
+ * Formatting and presentation logic
+ * ```ts
+ * type Price = { amount: number; currency: string };
+ *
+ * const priceSource = source<Price>();
+ *
+ * // Format price for display
+ * const formattedPriceSource = computedSource(
+ *   priceSource,
+ *   (price) => {
+ *     const formatter = new Intl.NumberFormat('en-US', {
+ *       style: 'currency',
+ *       currency: price.currency,
+ *     });
+ *     return formatter.format(price.amount);
+ *   }
+ * );
+ *
+ * // Use formatted value in UI updates
+ * const updatePriceDisplay = craftUse(asyncProcess({
+ *   method: afterRecomputation(formattedPriceSource, (formatted) => formatted),
+ *   loader: async ({ params }) => {
+ *     // Update analytics or external service
+ *     await trackPriceView(params);
+ *     return { displayed: params };
+ *   },
+ * }));
+ *
+ * priceSource.set({ amount: 1234.56, currency: 'USD' });
+ * // -> formattedPriceSource emits '$1,234.56'
+ * ```
+ *
+ * @example
+ * Using preserveLastValue for immediate computed access
+ * ```ts
+ * const counterSource = source<number>();
+ *
+ * const doubledSource = computedSource(
+ *   counterSource,
+ *   (count) => count * 2
+ * );
+ *
+ * // Standard behavior
+ * console.log(doubledSource()); // undefined (no emission yet)
+ *
+ * counterSource.set(5);
+ * console.log(doubledSource()); // 10
+ *
+ * // Using preserveLastValue
+ * const immediateDoubled = doubledSource.preserveLastValue;
+ * console.log(immediateDoubled()); // 10 (gets last computed value immediately)
+ * ```
+ */
+export declare function computedSource<SourceState, ComputedValue>(signalOrigin: SignalSource<SourceState> | ReadonlySource<SourceState>, computedFn: (sourceValue: NoInfer<SourceState>) => ComputedValue, options?: {
+    equal?: ValueEqualityFn<NoInfer<ComputedValue> | undefined>;
+    debugName?: string;
+}): ReadonlySource<ComputedValue>;
+//# sourceMappingURL=computed-source.d.ts.map

package/src/lib/computed-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computed-source.d.ts","sourceRoot":"","sources":["../../../../../libs/core/src/lib/computed-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC5E,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAG/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsSG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,aAAa,EACvD,YAAY,EAAE,YAAY,CAAC,WAAW,CAAC,GAAG,cAAc,CAAC,WAAW,CAAC,EACrE,UAAU,EAAE,CAAC,WAAW,EAAE,OAAO,CAAC,WAAW,CAAC,KAAK,aAAa,EAChE,OAAO,CAAC,EAAE;IACR,KAAK,CAAC,EAAE,eAAe,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,SAAS,CAAC,CAAC;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GACA,cAAc,CAAC,aAAa,CAAC,CA0B/B"}

package/src/lib/computed-source.js

@@ -0,0 +1,319 @@
+import { linkedSignal } from './host/craft-compat';
+import { SourceBranded } from './util/util';
+/**
+ * Creates a derived readonly source that transforms values from an origin source using a computation function.
+ *
+ * This function enables reactive transformations of source emissions by:
+ * - Computing new values whenever the origin source emits
+ * - Maintaining source semantics (emits only when explicitly set, not on first read)
+ * - Supporting custom equality comparisons for memoization
+ * - Providing both standard and value-preserving listeners
+ * - Creating composable source pipelines
+ *
+ * @remarks
+ * **Emission Behavior:**
+ * - Only emits when the origin source emits (explicit set/update)
+ * - First read returns `undefined` by default (maintains source semantics)
+ * - Use `preserveLastValue` variant to get computed value on first read
+ *
+ * **Use Cases:**
+ * - **Data transformation**: Convert source payloads to different shapes
+ * - **Filtering**: Extract specific fields from complex source data
+ * - **Formatting**: Apply formatting logic to source values
+ * - **Type narrowing**: Cast or validate source data types
+ * - **Composition**: Chain multiple source transformations
+ * - **Business logic**: Apply domain-specific computations
+ *
+ * **Source vs Signal:**
+ * - Sources emit only on explicit events (set/update calls)
+ * - Signals recompute on every access when dependencies change
+ * - computedSource maintains source lazy behavior
+ *
+ * **Equality Comparison:**
+ * - Default: Uses Angular's default equality check
+ * - Custom: Provide `equal` option for custom comparison
+ * - Prevents unnecessary emissions when computed value hasn't changed
+ *
+ * @template SourceState - The type of values emitted by the origin source
+ * @template ComputedValue - The type of values produced by the computation
+ *
+ * @param signalOrigin - The source or readonly source to derive from.
+ *   Values emitted by this source are passed to the computation function.
+ *
+ * @param computedFn - Function that transforms source values to computed values.
+ *   Called each time the origin source emits.
+ *
+ * @param options - Optional configuration:
+ *   - `equal`: Custom equality function for computed values
+ *   - `debugName`: Name for debugging purposes
+ *
+ * @returns A readonly source that emits computed values with:
+ *   - Standard behavior: First read returns `undefined`, subsequent reads return computed value after source emits
+ *   - `preserveLastValue` property: Returns computed value immediately on first read if source has emitted
+ *
+ * @example
+ * Basic transformation of source data
+ * ```ts
+ * const userSource = source<{ firstName: string; lastName: string }>();
+ *
+ * // Compute full name from user data
+ * const fullNameSource = computedSource(
+ *   userSource,
+ *   (user) => `${user.firstName} ${user.lastName}`
+ * );
+ *
+ * // Use in async method or query
+ * const greetUser = craftUse(asyncProcess({
+ *   method: afterRecomputation(fullNameSource, (fullName) => fullName),
+ *   loader: async ({ params }) => {
+ *     return `Hello, ${params}!`;
+ *   },
+ * }));
+ *
+ * // Trigger chain
+ * userSource.set({ firstName: 'John', lastName: 'Doe' });
+ * // -> fullNameSource emits 'John Doe'
+ * // -> greetUser executes with 'John Doe'
+ * ```
+ *
+ * @example
+ * Extracting specific fields from complex data
+ * ```ts
+ * type FormData = {
+ *   personal: { name: string; email: string };
+ *   address: { street: string; city: string };
+ *   preferences: { newsletter: boolean };
+ * };
+ *
+ * const formSource = source<FormData>();
+ *
+ * // Extract only email for validation
+ * const emailSource = computedSource(
+ *   formSource,
+ *   (form) => form.personal.email
+ * );
+ *
+ * // Extract only address for geocoding
+ * const addressSource = computedSource(
+ *   formSource,
+ *   (form) => form.address
+ * );
+ *
+ * // Use extracted sources
+ * const validateEmail = craftUse(asyncProcess({
+ *   method: afterRecomputation(emailSource, (email) => email),
+ *   loader: async ({ params }) => {
+ *     const response = await fetch('/api/validate-email', {
+ *       method: 'POST',
+ *       body: JSON.stringify({ email: params }),
+ *     });
+ *     return response.json();
+ *   },
+ * }));
+ *
+ * // Update form triggers both validations
+ * formSource.set({
+ *   personal: { name: 'John', email: 'john@example.com' },
+ *   address: { street: '123 Main St', city: 'NYC' },
+ *   preferences: { newsletter: true },
+ * });
+ * ```
+ *
+ * @example
+ * Chaining computed sources for multi-step transformation
+ * ```ts
+ * const inputSource = source<string>();
+ *
+ * // Step 1: Trim and lowercase
+ * const normalizedSource = computedSource(
+ *   inputSource,
+ *   (input) => input.trim().toLowerCase()
+ * );
+ *
+ * // Step 2: Extract search terms
+ * const searchTermsSource = computedSource(
+ *   normalizedSource,
+ *   (normalized) => normalized.split(' ').filter(term => term.length > 0)
+ * );
+ *
+ * // Step 3: Create search query
+ * const searchQuerySource = computedSource(
+ *   searchTermsSource,
+ *   (terms) => ({ terms, operator: 'AND' as const })
+ * );
+ *
+ * // Final async method uses fully transformed data
+ * const search = craftUse(asyncProcess({
+ *   method: afterRecomputation(searchQuerySource, (query) => query),
+ *   loader: async ({ params }) => {
+ *     const response = await fetch('/api/search', {
+ *       method: 'POST',
+ *       body: JSON.stringify(params),
+ *     });
+ *     return response.json();
+ *   },
+ * }));
+ *
+ * // Single input triggers entire chain
+ * inputSource.set('  Angular  Signals  ');
+ * // -> normalizedSource emits 'angular signals'
+ * // -> searchTermsSource emits ['angular', 'signals']
+ * // -> searchQuerySource emits { terms: ['angular', 'signals'], operator: 'AND' }
+ * // -> search executes
+ * ```
+ *
+ * @example
+ * Custom equality comparison
+ * ```ts
+ * type SearchParams = { query: string; timestamp: number };
+ *
+ * const searchSource = source<SearchParams>();
+ *
+ * // Only emit when query changes, ignore timestamp
+ * const queryOnlySource = computedSource(
+ *   searchSource,
+ *   (params) => params.query,
+ *   {
+ *     equal: (a, b) => a === b, // Compare strings
+ *   }
+ * );
+ *
+ * // Update with same query but different timestamp
+ * searchSource.set({ query: 'test', timestamp: Date.now() });
+ * // -> queryOnlySource emits 'test'
+ *
+ * searchSource.set({ query: 'test', timestamp: Date.now() });
+ * // -> queryOnlySource does NOT emit (same query)
+ *
+ * searchSource.set({ query: 'new', timestamp: Date.now() });
+ * // -> queryOnlySource emits 'new'
+ * ```
+ *
+ * @example
+ * Type narrowing and validation
+ * ```ts
+ * type ApiResponse =
+ *   | { type: 'success'; data: unknown }
+ *   | { type: 'error'; message: string };
+ *
+ * const responseSource = source<ApiResponse>();
+ *
+ * // Extract only successful data
+ * const successDataSource = computedSource(
+ *   responseSource,
+ *   (response) => {
+ *     if (response.type === 'success') {
+ *       return response.data;
+ *     }
+ *     return null;
+ *   }
+ * );
+ *
+ * // Extract only errors
+ * const errorSource = computedSource(
+ *   responseSource,
+ *   (response) => {
+ *     if (response.type === 'error') {
+ *       return response.message;
+ *     }
+ *     return null;
+ *   }
+ * );
+ *
+ * // Handle success and errors separately
+ * const Processuccess = craftUse(asyncProcess({
+ *   method: afterRecomputation(successDataSource, (data) => data),
+ *   loader: async ({ params }) => {
+ *     if (!params) return null;
+ *     // Process successful data
+ *     return processData(params);
+ *   },
+ * }));
+ *
+ * const logError = craftUse(asyncProcess({
+ *   method: afterRecomputation(errorSource, (error) => error),
+ *   loader: async ({ params }) => {
+ *     if (!params) return null;
+ *     // Log error
+ *     await logToService(params);
+ *     return { logged: true };
+ *   },
+ * }));
+ * ```
+ *
+ * @example
+ * Formatting and presentation logic
+ * ```ts
+ * type Price = { amount: number; currency: string };
+ *
+ * const priceSource = source<Price>();
+ *
+ * // Format price for display
+ * const formattedPriceSource = computedSource(
+ *   priceSource,
+ *   (price) => {
+ *     const formatter = new Intl.NumberFormat('en-US', {
+ *       style: 'currency',
+ *       currency: price.currency,
+ *     });
+ *     return formatter.format(price.amount);
+ *   }
+ * );
+ *
+ * // Use formatted value in UI updates
+ * const updatePriceDisplay = craftUse(asyncProcess({
+ *   method: afterRecomputation(formattedPriceSource, (formatted) => formatted),
+ *   loader: async ({ params }) => {
+ *     // Update analytics or external service
+ *     await trackPriceView(params);
+ *     return { displayed: params };
+ *   },
+ * }));
+ *
+ * priceSource.set({ amount: 1234.56, currency: 'USD' });
+ * // -> formattedPriceSource emits '$1,234.56'
+ * ```
+ *
+ * @example
+ * Using preserveLastValue for immediate computed access
+ * ```ts
+ * const counterSource = source<number>();
+ *
+ * const doubledSource = computedSource(
+ *   counterSource,
+ *   (count) => count * 2
+ * );
+ *
+ * // Standard behavior
+ * console.log(doubledSource()); // undefined (no emission yet)
+ *
+ * counterSource.set(5);
+ * console.log(doubledSource()); // 10
+ *
+ * // Using preserveLastValue
+ * const immediateDoubled = doubledSource.preserveLastValue;
+ * console.log(immediateDoubled()); // 10 (gets last computed value immediately)
+ * ```
+ */
+export function computedSource(signalOrigin, computedFn, options) {
+    const listener = (listenerOptions) => linkedSignal({
+        source: signalOrigin,
+        computation: (currentSourceState, previousData) => {
+            // always when first listened return undefined
+            if (!previousData && listenerOptions?.nullishFirstValue !== false) {
+                return undefined;
+            }
+            return computedFn(currentSourceState);
+        },
+        ...(options?.equal && { equal: options?.equal }),
+        ...(options?.debugName && { debugName: options?.debugName }),
+    });
+    return Object.assign(listener({
+        nullishFirstValue: true,
+    }), {
+        preserveLastValue: listener({
+            nullishFirstValue: false,
+        }),
+    }, SourceBranded);
+}
+//# sourceMappingURL=computed-source.js.map

package/src/lib/computed-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"computed-source.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/computed-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAA2B,MAAM,qBAAqB,CAAC;AAG5E,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsSG;AACH,MAAM,UAAU,cAAc,CAC5B,YAAqE,EACrE,UAAgE,EAChE,OAGC;IAED,MAAM,QAAQ,GAAG,CAAC,eAAgD,EAAE,EAAE,CACpE,YAAY,CAAyC;QACnD,MAAM,EAAE,YAAmC;QAC3C,WAAW,EAAE,CAAC,kBAAkB,EAAE,YAAY,EAAE,EAAE;YAChD,8CAA8C;YAC9C,IAAI,CAAC,YAAY,IAAI,eAAe,EAAE,iBAAiB,KAAK,KAAK,EAAE,CAAC;gBAClE,OAAO,SAAS,CAAC;YACnB,CAAC;YAED,OAAO,UAAU,CAAC,kBAAkB,CAAC,CAAC;QACxC,CAAC;QACD,GAAG,CAAC,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;QAChD,GAAG,CAAC,OAAO,EAAE,SAAS,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;KAC7D,CAAC,CAAC;IACL,OAAO,MAAM,CAAC,MAAM,CAClB,QAAQ,CAAC;QACP,iBAAiB,EAAE,IAAI;KACxB,CAAC,EACF;QACE,iBAAiB,EAAE,QAAQ,CAAC;YAC1B,iBAAiB,EAAE,KAAK;SACzB,CAAC;KACH,EACD,aAAa,CACS,CAAC;AAC3B,CAAC","sourcesContent":["import { linkedSignal, Signal, ValueEqualityFn } from './host/craft-compat';\nimport { ReadonlySource } from './util/source.type';\nimport { SignalSource } from './signal-source';\nimport { SourceBranded } from './util/util';\n\n/**\n * Creates a derived readonly source that transforms values from an origin source using a computation function.\n *\n * This function enables reactive transformations of source emissions by:\n * - Computing new values whenever the origin source emits\n * - Maintaining source semantics (emits only when explicitly set, not on first read)\n * - Supporting custom equality comparisons for memoization\n * - Providing both standard and value-preserving listeners\n * - Creating composable source pipelines\n *\n * @remarks\n * **Emission Behavior:**\n * - Only emits when the origin source emits (explicit set/update)\n * - First read returns `undefined` by default (maintains source semantics)\n * - Use `preserveLastValue` variant to get computed value on first read\n *\n * **Use Cases:**\n * - **Data transformation**: Convert source payloads to different shapes\n * - **Filtering**: Extract specific fields from complex source data\n * - **Formatting**: Apply formatting logic to source values\n * - **Type narrowing**: Cast or validate source data types\n * - **Composition**: Chain multiple source transformations\n * - **Business logic**: Apply domain-specific computations\n *\n * **Source vs Signal:**\n * - Sources emit only on explicit events (set/update calls)\n * - Signals recompute on every access when dependencies change\n * - computedSource maintains source lazy behavior\n *\n * **Equality Comparison:**\n * - Default: Uses Angular's default equality check\n * - Custom: Provide `equal` option for custom comparison\n * - Prevents unnecessary emissions when computed value hasn't changed\n *\n * @template SourceState - The type of values emitted by the origin source\n * @template ComputedValue - The type of values produced by the computation\n *\n * @param signalOrigin - The source or readonly source to derive from.\n *   Values emitted by this source are passed to the computation function.\n *\n * @param computedFn - Function that transforms source values to computed values.\n *   Called each time the origin source emits.\n *\n * @param options - Optional configuration:\n *   - `equal`: Custom equality function for computed values\n *   - `debugName`: Name for debugging purposes\n *\n * @returns A readonly source that emits computed values with:\n *   - Standard behavior: First read returns `undefined`, subsequent reads return computed value after source emits\n *   - `preserveLastValue` property: Returns computed value immediately on first read if source has emitted\n *\n * @example\n * Basic transformation of source data\n * ```ts\n * const userSource = source<{ firstName: string; lastName: string }>();\n *\n * // Compute full name from user data\n * const fullNameSource = computedSource(\n *   userSource,\n *   (user) => `${user.firstName} ${user.lastName}`\n * );\n *\n * // Use in async method or query\n * const greetUser = craftUse(asyncProcess({\n *   method: afterRecomputation(fullNameSource, (fullName) => fullName),\n *   loader: async ({ params }) => {\n *     return `Hello, ${params}!`;\n *   },\n * }));\n *\n * // Trigger chain\n * userSource.set({ firstName: 'John', lastName: 'Doe' });\n * // -> fullNameSource emits 'John Doe'\n * // -> greetUser executes with 'John Doe'\n * ```\n *\n * @example\n * Extracting specific fields from complex data\n * ```ts\n * type FormData = {\n *   personal: { name: string; email: string };\n *   address: { street: string; city: string };\n *   preferences: { newsletter: boolean };\n * };\n *\n * const formSource = source<FormData>();\n *\n * // Extract only email for validation\n * const emailSource = computedSource(\n *   formSource,\n *   (form) => form.personal.email\n * );\n *\n * // Extract only address for geocoding\n * const addressSource = computedSource(\n *   formSource,\n *   (form) => form.address\n * );\n *\n * // Use extracted sources\n * const validateEmail = craftUse(asyncProcess({\n *   method: afterRecomputation(emailSource, (email) => email),\n *   loader: async ({ params }) => {\n *     const response = await fetch('/api/validate-email', {\n *       method: 'POST',\n *       body: JSON.stringify({ email: params }),\n *     });\n *     return response.json();\n *   },\n * }));\n *\n * // Update form triggers both validations\n * formSource.set({\n *   personal: { name: 'John', email: 'john@example.com' },\n *   address: { street: '123 Main St', city: 'NYC' },\n *   preferences: { newsletter: true },\n * });\n * ```\n *\n * @example\n * Chaining computed sources for multi-step transformation\n * ```ts\n * const inputSource = source<string>();\n *\n * // Step 1: Trim and lowercase\n * const normalizedSource = computedSource(\n *   inputSource,\n *   (input) => input.trim().toLowerCase()\n * );\n *\n * // Step 2: Extract search terms\n * const searchTermsSource = computedSource(\n *   normalizedSource,\n *   (normalized) => normalized.split(' ').filter(term => term.length > 0)\n * );\n *\n * // Step 3: Create search query\n * const searchQuerySource = computedSource(\n *   searchTermsSource,\n *   (terms) => ({ terms, operator: 'AND' as const })\n * );\n *\n * // Final async method uses fully transformed data\n * const search = craftUse(asyncProcess({\n *   method: afterRecomputation(searchQuerySource, (query) => query),\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 * // Single input triggers entire chain\n * inputSource.set('  Angular  Signals  ');\n * // -> normalizedSource emits 'angular signals'\n * // -> searchTermsSource emits ['angular', 'signals']\n * // -> searchQuerySource emits { terms: ['angular', 'signals'], operator: 'AND' }\n * // -> search executes\n * ```\n *\n * @example\n * Custom equality comparison\n * ```ts\n * type SearchParams = { query: string; timestamp: number };\n *\n * const searchSource = source<SearchParams>();\n *\n * // Only emit when query changes, ignore timestamp\n * const queryOnlySource = computedSource(\n *   searchSource,\n *   (params) => params.query,\n *   {\n *     equal: (a, b) => a === b, // Compare strings\n *   }\n * );\n *\n * // Update with same query but different timestamp\n * searchSource.set({ query: 'test', timestamp: Date.now() });\n * // -> queryOnlySource emits 'test'\n *\n * searchSource.set({ query: 'test', timestamp: Date.now() });\n * // -> queryOnlySource does NOT emit (same query)\n *\n * searchSource.set({ query: 'new', timestamp: Date.now() });\n * // -> queryOnlySource emits 'new'\n * ```\n *\n * @example\n * Type narrowing and validation\n * ```ts\n * type ApiResponse =\n *   | { type: 'success'; data: unknown }\n *   | { type: 'error'; message: string };\n *\n * const responseSource = source<ApiResponse>();\n *\n * // Extract only successful data\n * const successDataSource = computedSource(\n *   responseSource,\n *   (response) => {\n *     if (response.type === 'success') {\n *       return response.data;\n *     }\n *     return null;\n *   }\n * );\n *\n * // Extract only errors\n * const errorSource = computedSource(\n *   responseSource,\n *   (response) => {\n *     if (response.type === 'error') {\n *       return response.message;\n *     }\n *     return null;\n *   }\n * );\n *\n * // Handle success and errors separately\n * const Processuccess = craftUse(asyncProcess({\n *   method: afterRecomputation(successDataSource, (data) => data),\n *   loader: async ({ params }) => {\n *     if (!params) return null;\n *     // Process successful data\n *     return processData(params);\n *   },\n * }));\n *\n * const logError = craftUse(asyncProcess({\n *   method: afterRecomputation(errorSource, (error) => error),\n *   loader: async ({ params }) => {\n *     if (!params) return null;\n *     // Log error\n *     await logToService(params);\n *     return { logged: true };\n *   },\n * }));\n * ```\n *\n * @example\n * Formatting and presentation logic\n * ```ts\n * type Price = { amount: number; currency: string };\n *\n * const priceSource = source<Price>();\n *\n * // Format price for display\n * const formattedPriceSource = computedSource(\n *   priceSource,\n *   (price) => {\n *     const formatter = new Intl.NumberFormat('en-US', {\n *       style: 'currency',\n *       currency: price.currency,\n *     });\n *     return formatter.format(price.amount);\n *   }\n * );\n *\n * // Use formatted value in UI updates\n * const updatePriceDisplay = craftUse(asyncProcess({\n *   method: afterRecomputation(formattedPriceSource, (formatted) => formatted),\n *   loader: async ({ params }) => {\n *     // Update analytics or external service\n *     await trackPriceView(params);\n *     return { displayed: params };\n *   },\n * }));\n *\n * priceSource.set({ amount: 1234.56, currency: 'USD' });\n * // -> formattedPriceSource emits '$1,234.56'\n * ```\n *\n * @example\n * Using preserveLastValue for immediate computed access\n * ```ts\n * const counterSource = source<number>();\n *\n * const doubledSource = computedSource(\n *   counterSource,\n *   (count) => count * 2\n * );\n *\n * // Standard behavior\n * console.log(doubledSource()); // undefined (no emission yet)\n *\n * counterSource.set(5);\n * console.log(doubledSource()); // 10\n *\n * // Using preserveLastValue\n * const immediateDoubled = doubledSource.preserveLastValue;\n * console.log(immediateDoubled()); // 10 (gets last computed value immediately)\n * ```\n */\nexport function computedSource<SourceState, ComputedValue>(\n  signalOrigin: SignalSource<SourceState> | ReadonlySource<SourceState>,\n  computedFn: (sourceValue: NoInfer<SourceState>) => ComputedValue,\n  options?: {\n    equal?: ValueEqualityFn<NoInfer<ComputedValue> | undefined>;\n    debugName?: string;\n  },\n): ReadonlySource<ComputedValue> {\n  const listener = (listenerOptions: { nullishFirstValue?: boolean }) =>\n    linkedSignal<SourceState, ComputedValue | undefined>({\n      source: signalOrigin as Signal<SourceState>,\n      computation: (currentSourceState, previousData) => {\n        // always when first listened return undefined\n        if (!previousData && listenerOptions?.nullishFirstValue !== false) {\n          return undefined;\n        }\n\n        return computedFn(currentSourceState);\n      },\n      ...(options?.equal && { equal: options?.equal }),\n      ...(options?.debugName && { debugName: options?.debugName }),\n    });\n  return Object.assign(\n    listener({\n      nullishFirstValue: true,\n    }),\n    {\n      preserveLastValue: listener({\n        nullishFirstValue: false,\n      }),\n    },\n    SourceBranded,\n  ) as ReadonlySource<any>;\n}\n"]}

package/src/lib/correlation-id-plugin.d.ts

@@ -0,0 +1,3 @@
+import { type EnvironmentProviders, type Provider } from './host/craft-compat';
+export declare function provideCorrelationIdTracking(): (Provider | EnvironmentProviders)[];
+//# sourceMappingURL=correlation-id-plugin.d.ts.map

package/src/lib/correlation-id-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correlation-id-plugin.d.ts","sourceRoot":"","sources":["../../../../../libs/core/src/lib/correlation-id-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,oBAAoB,EACzB,KAAK,QAAQ,EACd,MAAM,qBAAqB,CAAC;AAmF7B,wBAAgB,4BAA4B,IAAI,CAC5C,QAAQ,GACR,oBAAoB,CACvB,EAAE,CAgBF"}