@signality/core 0.0.1-alpha.2

package/fesm2022/signality-core-observers-mutation-observer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signality-core-observers-mutation-observer.mjs","sources":["../../../projects/core/observers/mutation-observer/index.ts","../../../projects/core/observers/mutation-observer/signality-core-observers-mutation-observer.ts"],"sourcesContent":["import {\n  afterRenderEffect,\n  type CreateEffectOptions,\n  type EffectCleanupRegisterFn,\n} from '@angular/core';\nimport { NOOP_EFFECT_REF, setupContext, toElement, toValue } from '@signality/core/internal';\nimport type { MaybeElementSignal, MaybeSignal } from '@signality/core/types';\n\nexport interface MutationObserverInitOptions\n  extends Omit<CreateEffectOptions, 'allowSignalWrites'> {\n  readonly childList?: MaybeSignal<boolean>;\n  readonly attributes?: MaybeSignal<boolean>;\n  readonly characterData?: MaybeSignal<boolean>;\n  readonly subtree?: MaybeSignal<boolean>;\n  readonly attributeOldValue?: MaybeSignal<boolean>;\n  readonly characterDataOldValue?: MaybeSignal<boolean>;\n  readonly attributeFilter?: MaybeSignal<string[]>;\n}\n\nexport interface MutationObserverRef {\n  readonly destroy: () => void;\n}\n\n/**\n * Low-level utility for observing DOM tree changes using the [MutationObserver API](https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver).\n * Provides fine-grained control over the observation lifecycle.\n *\n * @param target - Element(s) to observe\n * @param callback - Callback function called when DOM mutations occur\n * @param options - Optional configuration (see {@link MutationObserverInitOptions})\n * @returns MutationObserverRef with a `destroy()` method to stop observing the element(s)\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     <div #container>\n *       <p>Children: {{ childCount() }}</p>\n *     </div>\n *   `\n * })\n * class MutationComponent {\n *   readonly container = viewChild<ElementRef>('container');\n *   readonly childCount = signal(0);\n *\n *   constructor() {\n *     mutationObserver(this.container, mutations => {\n *       this.childCount.set(mutations[0].target.childNodes.length);\n *     }, { childList: true });\n *   }\n * }\n * ```\n */\nexport function mutationObserver(\n  target: MaybeElementSignal<Element> | MaybeElementSignal<Element>[],\n  callback: (mutations: readonly MutationRecord[], observer: MutationObserver) => void,\n  options: MutationObserverInitOptions\n): MutationObserverRef {\n  const { runInContext } = setupContext(options.injector, mutationObserver);\n\n  return runInContext(({ isServer }) => {\n    if (isServer) {\n      return NOOP_EFFECT_REF;\n    }\n\n    const targets = Array.isArray(target) ? target : [target];\n\n    const setupObserver = (onCleanup: EffectCleanupRegisterFn) => {\n      const els = targets.map(toElement).filter(Boolean);\n\n      if (!els.length) {\n        return;\n      }\n\n      const childList = toValue(options.childList);\n      const attributes = toValue(options.attributes);\n      const characterData = toValue(options.characterData);\n      const subtree = toValue(options.subtree);\n      const attributeOldValue = toValue(options.attributeOldValue);\n      const characterDataOldValue = toValue(options.characterDataOldValue);\n      const attributeFilter = toValue(options.attributeFilter);\n\n      const observer = new MutationObserver(callback);\n\n      for (const el of els) {\n        observer.observe(el!, {\n          childList,\n          attributes,\n          characterData,\n          subtree,\n          attributeOldValue,\n          characterDataOldValue,\n          attributeFilter,\n        });\n      }\n\n      onCleanup(observer.disconnect.bind(observer));\n    };\n\n    const effectRef = afterRenderEffect({ read: setupObserver }, options);\n\n    return { destroy: () => effectRef.destroy() };\n  });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;SACa,gBAAgB,CAC9B,MAAmE,EACnE,QAAoF,EACpF,OAAoC,EAAA;AAEpC,IAAA,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CAAC,OAAO,CAAC,QAAQ,EAAE,gBAAgB,CAAC;AAEzE,IAAA,OAAO,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAI;QACnC,IAAI,QAAQ,EAAE;AACZ,YAAA,OAAO,eAAe;QACxB;AAEA,QAAA,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,GAAG,CAAC,MAAM,CAAC;AAEzD,QAAA,MAAM,aAAa,GAAG,CAAC,SAAkC,KAAI;AAC3D,YAAA,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC;AAElD,YAAA,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE;gBACf;YACF;YAEA,MAAM,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC;YAC5C,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC;YAC9C,MAAM,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC;YACpD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC;YACxC,MAAM,iBAAiB,GAAG,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC;YAC5D,MAAM,qBAAqB,GAAG,OAAO,CAAC,OAAO,CAAC,qBAAqB,CAAC;YACpE,MAAM,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC;AAExD,YAAA,MAAM,QAAQ,GAAG,IAAI,gBAAgB,CAAC,QAAQ,CAAC;AAE/C,YAAA,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE;AACpB,gBAAA,QAAQ,CAAC,OAAO,CAAC,EAAG,EAAE;oBACpB,SAAS;oBACT,UAAU;oBACV,aAAa;oBACb,OAAO;oBACP,iBAAiB;oBACjB,qBAAqB;oBACrB,eAAe;AAChB,iBAAA,CAAC;YACJ;YAEA,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AAC/C,QAAA,CAAC;AAED,QAAA,MAAM,SAAS,GAAG,iBAAiB,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,EAAE,OAAO,CAAC;QAErE,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC,OAAO,EAAE,EAAE;AAC/C,IAAA,CAAC,CAAC;AACJ;;ACvGA;;AAEG;;;;"}

package/fesm2022/signality-core-observers-performance-observer.mjs

@@ -0,0 +1,84 @@
+import { afterRenderEffect } from '@angular/core';
+import { setupContext, NOOP_EFFECT_REF, toValue } from '@signality/core/internal';
+
+/**
+ * Low-level utility for observing performance measurement events using the [Performance Observer API](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver).
+ * Provides reactive access to performance entries as they are recorded in the browser's performance timeline.
+ *
+ * @param callback - Callback function called when performance entries are recorded
+ * @param options - Optional configuration (see {@link PerformanceObserverInitOptions})
+ * @returns PerformanceObserverRef with a `destroy()` method to stop observing
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     <div>LCP: {{ lcp() }}ms</div>
+ *   `
+ * })
+ * class PerformanceComponent {
+ *   readonly lcp = signal(0);
+ *
+ *   constructor() {
+ *     performanceObserver(entries => {
+ *       const lcpEntry = entries.find(e => e.entryType === 'largest-contentful-paint');
+ *       if (lcpEntry) {
+ *         this.lcp.set(Math.round(lcpEntry.startTime));
+ *       }
+ *     }, { entryTypes: ['largest-contentful-paint'] });
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Track long tasks
+ * performanceObserver(entries => {
+ *   entries.forEach(entry => {
+ *     console.log('Long task:', entry.duration);
+ *   });
+ * }, { entryTypes: ['longtask'] });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using type (single entry type, legacy API)
+ * performanceObserver(entries => {
+ *   console.log('Navigation timing:', entries[0]);
+ * }, { type: 'navigation', buffered: true });
+ * ```
+ */
+function performanceObserver(callback, options) {
+    const { runInContext } = setupContext(options?.injector, performanceObserver);
+    return runInContext(({ isServer }) => {
+        if (isServer) {
+            return NOOP_EFFECT_REF;
+        }
+        const setupObserver = (onCleanup) => {
+            const entryTypes = toValue(options?.entryTypes);
+            const type = toValue(options?.type);
+            const buffered = toValue(options?.buffered);
+            if (!entryTypes && !type) {
+                console.warn('[PerformanceObserver] Either entryTypes or type must be provided. ' +
+                    'See https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver/observe');
+                return;
+            }
+            const observer = new PerformanceObserver(callback);
+            observer.observe({
+                entryTypes,
+                type,
+                buffered,
+            });
+            onCleanup(observer.disconnect.bind(observer));
+        };
+        const effectRef = afterRenderEffect({ read: setupObserver }, options);
+        return { destroy: () => effectRef.destroy() };
+    });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { performanceObserver };
+//# sourceMappingURL=signality-core-observers-performance-observer.mjs.map

package/fesm2022/signality-core-observers-performance-observer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signality-core-observers-performance-observer.mjs","sources":["../../../projects/core/observers/performance-observer/index.ts","../../../projects/core/observers/performance-observer/signality-core-observers-performance-observer.ts"],"sourcesContent":["import {\n  afterRenderEffect,\n  type CreateEffectOptions,\n  type EffectCleanupRegisterFn,\n} from '@angular/core';\nimport { NOOP_EFFECT_REF, setupContext, toValue } from '@signality/core/internal';\nimport type { MaybeSignal } from '@signality/core/types';\n\nexport interface PerformanceObserverInitOptions\n  extends Omit<CreateEffectOptions, 'allowSignalWrites'> {\n  readonly entryTypes?: MaybeSignal<string[]>;\n  readonly type?: MaybeSignal<string>;\n  readonly buffered?: MaybeSignal<boolean>;\n}\n\nexport interface PerformanceObserverRef {\n  readonly destroy: () => void;\n}\n\n/**\n * Low-level utility for observing performance measurement events using the [Performance Observer API](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver).\n * Provides reactive access to performance entries as they are recorded in the browser's performance timeline.\n *\n * @param callback - Callback function called when performance entries are recorded\n * @param options - Optional configuration (see {@link PerformanceObserverInitOptions})\n * @returns PerformanceObserverRef with a `destroy()` method to stop observing\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     <div>LCP: {{ lcp() }}ms</div>\n *   `\n * })\n * class PerformanceComponent {\n *   readonly lcp = signal(0);\n *\n *   constructor() {\n *     performanceObserver(entries => {\n *       const lcpEntry = entries.find(e => e.entryType === 'largest-contentful-paint');\n *       if (lcpEntry) {\n *         this.lcp.set(Math.round(lcpEntry.startTime));\n *       }\n *     }, { entryTypes: ['largest-contentful-paint'] });\n *   }\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Track long tasks\n * performanceObserver(entries => {\n *   entries.forEach(entry => {\n *     console.log('Long task:', entry.duration);\n *   });\n * }, { entryTypes: ['longtask'] });\n * ```\n *\n * @example\n * ```typescript\n * // Using type (single entry type, legacy API)\n * performanceObserver(entries => {\n *   console.log('Navigation timing:', entries[0]);\n * }, { type: 'navigation', buffered: true });\n * ```\n */\nexport function performanceObserver(\n  callback: PerformanceObserverCallback,\n  options?: PerformanceObserverInitOptions\n): PerformanceObserverRef {\n  const { runInContext } = setupContext(options?.injector, performanceObserver);\n\n  return runInContext(({ isServer }) => {\n    if (isServer) {\n      return NOOP_EFFECT_REF;\n    }\n\n    const setupObserver = (onCleanup: EffectCleanupRegisterFn) => {\n      const entryTypes = toValue(options?.entryTypes);\n      const type = toValue(options?.type);\n      const buffered = toValue(options?.buffered);\n\n      if (!entryTypes && !type) {\n        console.warn(\n          '[PerformanceObserver] Either entryTypes or type must be provided. ' +\n            'See https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver/observe'\n        );\n        return;\n      }\n\n      const observer = new PerformanceObserver(callback);\n\n      observer.observe({\n        entryTypes,\n        type,\n        buffered,\n      });\n\n      onCleanup(observer.disconnect.bind(observer));\n    };\n\n    const effectRef = afterRenderEffect({ read: setupObserver }, options);\n\n    return { destroy: () => effectRef.destroy() };\n  });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CG;AACG,SAAU,mBAAmB,CACjC,QAAqC,EACrC,OAAwC,EAAA;AAExC,IAAA,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,mBAAmB,CAAC;AAE7E,IAAA,OAAO,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAI;QACnC,IAAI,QAAQ,EAAE;AACZ,YAAA,OAAO,eAAe;QACxB;AAEA,QAAA,MAAM,aAAa,GAAG,CAAC,SAAkC,KAAI;YAC3D,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,EAAE,UAAU,CAAC;YAC/C,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC;YACnC,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,EAAE,QAAQ,CAAC;AAE3C,YAAA,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,EAAE;gBACxB,OAAO,CAAC,IAAI,CACV,oEAAoE;AAClE,oBAAA,kFAAkF,CACrF;gBACD;YACF;AAEA,YAAA,MAAM,QAAQ,GAAG,IAAI,mBAAmB,CAAC,QAAQ,CAAC;YAElD,QAAQ,CAAC,OAAO,CAAC;gBACf,UAAU;gBACV,IAAI;gBACJ,QAAQ;AACT,aAAA,CAAC;YAEF,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AAC/C,QAAA,CAAC;AAED,QAAA,MAAM,SAAS,GAAG,iBAAiB,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,EAAE,OAAO,CAAC;QAErE,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC,OAAO,EAAE,EAAE;AAC/C,IAAA,CAAC,CAAC;AACJ;;ACzGA;;AAEG;;;;"}

package/fesm2022/signality-core-observers-resize-observer.mjs

@@ -0,0 +1,69 @@
+import { afterRenderEffect } from '@angular/core';
+import { setupContext, NOOP_EFFECT_REF, toElement, toValue } from '@signality/core/internal';
+
+/**
+ * Low-level utility for observing element size changes using the [ResizeObserver API](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver).
+ * Provides fine-grained control over the observation lifecycle.
+ *
+ * @param target - Element(s) to observe
+ * @param callback - Callback function called when element size changes
+ * @param options - Optional configuration (see {@link ResizeObserverInitOptions})
+ * @returns ResizeObserverRef with a `destroy()` method to stop observing the element(s)
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     <div #resizable>
+ *       Size: {{ size().width }} × {{ size().height }}px
+ *     </div>
+ *   `
+ * })
+ * class ResizeComponent {
+ *   readonly resizable = viewChild<ElementRef>('resizable');
+ *   readonly size = signal({ width: 0, height: 0 });
+ *
+ *   constructor() {
+ *     resizeObserver(this.resizable, entries => {
+ *       const { width, height } = entries[0].contentRect;
+ *       this.size.set({ width, height });
+ *     });
+ *   }
+ * }
+ * ```
+ */
+function resizeObserver(target, callback, options) {
+    const { runInContext } = setupContext(options?.injector, resizeObserver);
+    return runInContext(({ isServer, onCleanup }) => {
+        if (isServer) {
+            return NOOP_EFFECT_REF;
+        }
+        const targets = Array.isArray(target) ? target : [target];
+        let observer = null;
+        const setupObserver = (onCleanup) => {
+            const els = targets.map(toElement).filter(Boolean);
+            if (!els.length) {
+                return;
+            }
+            const box = toValue(options?.box);
+            observer ??= new ResizeObserver(callback);
+            for (const el of els) {
+                observer.observe(el, { box });
+            }
+            onCleanup(() => {
+                els.forEach(el => observer?.unobserve(el));
+            });
+        };
+        const destroy = () => observer?.disconnect();
+        onCleanup(destroy);
+        afterRenderEffect({ read: setupObserver }, options);
+        return { destroy };
+    });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { resizeObserver };
+//# sourceMappingURL=signality-core-observers-resize-observer.mjs.map

package/fesm2022/signality-core-observers-resize-observer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signality-core-observers-resize-observer.mjs","sources":["../../../projects/core/observers/resize-observer/index.ts","../../../projects/core/observers/resize-observer/signality-core-observers-resize-observer.ts"],"sourcesContent":["import {\n  afterRenderEffect,\n  type CreateEffectOptions,\n  type EffectCleanupRegisterFn,\n} from '@angular/core';\nimport { NOOP_EFFECT_REF, setupContext, toElement, toValue } from '@signality/core/internal';\nimport type { MaybeElementSignal, MaybeSignal } from '@signality/core/types';\n\nexport interface ResizeObserverInitOptions extends Omit<CreateEffectOptions, 'allowSignalWrites'> {\n  readonly box?: MaybeSignal<ResizeObserverBoxOptions>;\n}\n\nexport interface ResizeObserverRef {\n  readonly destroy: () => void;\n}\n\n/**\n * Low-level utility for observing element size changes using the [ResizeObserver API](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver).\n * Provides fine-grained control over the observation lifecycle.\n *\n * @param target - Element(s) to observe\n * @param callback - Callback function called when element size changes\n * @param options - Optional configuration (see {@link ResizeObserverInitOptions})\n * @returns ResizeObserverRef with a `destroy()` method to stop observing the element(s)\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     <div #resizable>\n *       Size: {{ size().width }} × {{ size().height }}px\n *     </div>\n *   `\n * })\n * class ResizeComponent {\n *   readonly resizable = viewChild<ElementRef>('resizable');\n *   readonly size = signal({ width: 0, height: 0 });\n *\n *   constructor() {\n *     resizeObserver(this.resizable, entries => {\n *       const { width, height } = entries[0].contentRect;\n *       this.size.set({ width, height });\n *     });\n *   }\n * }\n * ```\n */\nexport function resizeObserver(\n  target: MaybeElementSignal<Element> | MaybeElementSignal<Element>[],\n  callback: (entries: readonly ResizeObserverEntry[]) => void,\n  options?: ResizeObserverInitOptions\n): ResizeObserverRef {\n  const { runInContext } = setupContext(options?.injector, resizeObserver);\n\n  return runInContext(({ isServer, onCleanup }) => {\n    if (isServer) {\n      return NOOP_EFFECT_REF;\n    }\n\n    const targets = Array.isArray(target) ? target : [target];\n\n    let observer: ResizeObserver | null = null;\n\n    const setupObserver = (onCleanup: EffectCleanupRegisterFn) => {\n      const els = targets.map(toElement).filter(Boolean);\n\n      if (!els.length) {\n        return;\n      }\n\n      const box = toValue(options?.box);\n\n      observer ??= new ResizeObserver(callback);\n\n      for (const el of els) {\n        observer.observe(el!, { box });\n      }\n\n      onCleanup(() => {\n        els.forEach(el => observer?.unobserve(el!));\n      });\n    };\n\n    const destroy = () => observer?.disconnect();\n\n    onCleanup(destroy);\n\n    afterRenderEffect({ read: setupObserver }, options);\n\n    return { destroy };\n  });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;SACa,cAAc,CAC5B,MAAmE,EACnE,QAA2D,EAC3D,OAAmC,EAAA;AAEnC,IAAA,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,cAAc,CAAC;IAExE,OAAO,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAI;QAC9C,IAAI,QAAQ,EAAE;AACZ,YAAA,OAAO,eAAe;QACxB;AAEA,QAAA,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,GAAG,CAAC,MAAM,CAAC;QAEzD,IAAI,QAAQ,GAA0B,IAAI;AAE1C,QAAA,MAAM,aAAa,GAAG,CAAC,SAAkC,KAAI;AAC3D,YAAA,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC;AAElD,YAAA,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE;gBACf;YACF;YAEA,MAAM,GAAG,GAAG,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC;AAEjC,YAAA,QAAQ,KAAK,IAAI,cAAc,CAAC,QAAQ,CAAC;AAEzC,YAAA,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE;gBACpB,QAAQ,CAAC,OAAO,CAAC,EAAG,EAAE,EAAE,GAAG,EAAE,CAAC;YAChC;YAEA,SAAS,CAAC,MAAK;AACb,gBAAA,GAAG,CAAC,OAAO,CAAC,EAAE,IAAI,QAAQ,EAAE,SAAS,CAAC,EAAG,CAAC,CAAC;AAC7C,YAAA,CAAC,CAAC;AACJ,QAAA,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,QAAQ,EAAE,UAAU,EAAE;QAE5C,SAAS,CAAC,OAAO,CAAC;QAElB,iBAAiB,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,EAAE,OAAO,CAAC;QAEnD,OAAO,EAAE,OAAO,EAAE;AACpB,IAAA,CAAC,CAAC;AACJ;;AC3FA;;AAEG;;;;"}

package/fesm2022/signality-core-observers.mjs

@@ -0,0 +1,9 @@
+export * from '@signality/core/observers/intersection-observer';
+export * from '@signality/core/observers/mutation-observer';
+export * from '@signality/core/observers/performance-observer';
+export * from '@signality/core/observers/resize-observer';
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+//# sourceMappingURL=signality-core-observers.mjs.map

package/fesm2022/signality-core-observers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signality-core-observers.mjs","sources":["../../../projects/core/observers/signality-core-observers.ts"],"sourcesContent":["/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;;;AAAA;;AAEG"}

package/fesm2022/signality-core-reactivity-debounced.mjs

@@ -0,0 +1,27 @@
+import { signal, isSignal } from '@angular/core';
+import { setupContext, toValue, proxySignal } from '@signality/core/internal';
+import { debounceCallback } from '@signality/core/scheduling/debounce-callback';
+import { watcher } from '@signality/core/reactivity/watcher';
+
+function debounced(valueOrSignal, timeMs, options) {
+    const { runInContext } = setupContext(options?.injector, debounced);
+    return runInContext(() => {
+        const initialValue = toValue(valueOrSignal);
+        const output = signal(initialValue, options);
+        const set = debounceCallback(output.set, timeMs);
+        if (isSignal(valueOrSignal)) {
+            watcher(valueOrSignal, set);
+            return output.asReadonly();
+        }
+        else {
+            return proxySignal(output, { set });
+        }
+    });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { debounced };
+//# sourceMappingURL=signality-core-reactivity-debounced.mjs.map

package/fesm2022/signality-core-reactivity-debounced.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signality-core-reactivity-debounced.mjs","sources":["../../../projects/core/reactivity/debounced/index.ts","../../../projects/core/reactivity/debounced/signality-core-reactivity-debounced.ts"],"sourcesContent":["import {\n  type CreateSignalOptions,\n  isSignal,\n  signal,\n  type Signal,\n  type WritableSignal,\n} from '@angular/core';\nimport { proxySignal, setupContext, toValue } from '@signality/core/internal';\nimport type { MaybeSignal, SignalValue, WithInjector } from '@signality/core/types';\nimport { debounceCallback } from '@signality/core/scheduling/debounce-callback';\nimport { watcher } from '@signality/core/reactivity/watcher';\n\nexport type DebouncedOptions<T> = CreateSignalOptions<T> & WithInjector;\n\n/**\n * Creates a debounced readonly signal from a source signal.\n * Updates to the source signal are debounced before propagating to the returned signal.\n *\n * @param source - Source signal to debounce\n * @param timeMs - Debounce delay in milliseconds\n * @param options - Optional configuration including signal options and injector\n * @returns A readonly signal that updates after the debounce delay\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     <input [(ngModel)]=\"query\" />\n *     <p>Debounced value: {{ debouncedQuery() }}</p>\n *   `\n * })\n * class SearchInput {\n *   readonly query = signal('');\n *   readonly debouncedQuery = debounced(this.query, 300);\n * }\n * ```\n */\nexport function debounced<S extends Signal<any>>(\n  source: S,\n  timeMs: MaybeSignal<number>,\n  options?: DebouncedOptions<SignalValue<S>>\n): Signal<SignalValue<S>>;\n\n/**\n * Creates a debounced writable signal from an initial value.\n * Both `set()` and `update()` calls are debounced.\n *\n * @param value - Initial value\n * @param timeMs - Debounce delay in milliseconds\n * @param options - Optional configuration including signal options and injector\n * @returns A writable signal where updates are debounced\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     <input [(ngModel)]=\"query\" />\n *     <p>Search results for: {{ query() }}</p>\n *   `\n * })\n * class SearchInput {\n *   readonly query = debounced('', 300);\n * }\n * ```\n */\nexport function debounced<V>(\n  value: V,\n  timeMs: MaybeSignal<number>,\n  options?: DebouncedOptions<V>\n): WritableSignal<V>;\n\nexport function debounced(\n  valueOrSignal: any,\n  timeMs: MaybeSignal<number>,\n  options?: DebouncedOptions<any>\n) {\n  const { runInContext } = setupContext(options?.injector, debounced);\n\n  return runInContext(() => {\n    const initialValue = toValue(valueOrSignal);\n    const output = signal(initialValue, options);\n    const set = debounceCallback(output.set, timeMs);\n\n    if (isSignal(valueOrSignal)) {\n      watcher(valueOrSignal, set);\n      return output.asReadonly();\n    } else {\n      return proxySignal(output, { set });\n    }\n  });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;;;SAuEgB,SAAS,CACvB,aAAkB,EAClB,MAA2B,EAC3B,OAA+B,EAAA;AAE/B,IAAA,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,SAAS,CAAC;IAEnE,OAAO,YAAY,CAAC,MAAK;AACvB,QAAA,MAAM,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;QAC3C,MAAM,MAAM,GAAG,MAAM,CAAC,YAAY,EAAE,OAAO,CAAC;QAC5C,MAAM,GAAG,GAAG,gBAAgB,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC;AAEhD,QAAA,IAAI,QAAQ,CAAC,aAAa,CAAC,EAAE;AAC3B,YAAA,OAAO,CAAC,aAAa,EAAE,GAAG,CAAC;AAC3B,YAAA,OAAO,MAAM,CAAC,UAAU,EAAE;QAC5B;aAAO;YACL,OAAO,WAAW,CAAC,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC;QACrC;AACF,IAAA,CAAC,CAAC;AACJ;;AC1FA;;AAEG;;;;"}

package/fesm2022/signality-core-reactivity-throttled.mjs

@@ -0,0 +1,27 @@
+import { signal, isSignal } from '@angular/core';
+import { setupContext, toValue, proxySignal } from '@signality/core/internal';
+import { throttleCallback } from '@signality/core/scheduling/throttle-callback';
+import { watcher } from '@signality/core/reactivity/watcher';
+
+function throttled(valueOrSignal, timeMs, options) {
+    const { runInContext } = setupContext(options?.injector, throttled);
+    return runInContext(() => {
+        const initialValue = toValue(valueOrSignal);
+        const output = signal(initialValue, options);
+        const set = throttleCallback(output.set, timeMs);
+        if (isSignal(valueOrSignal)) {
+            watcher(valueOrSignal, set);
+            return output.asReadonly();
+        }
+        else {
+            return proxySignal(output, { set });
+        }
+    });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { throttled };
+//# sourceMappingURL=signality-core-reactivity-throttled.mjs.map

package/fesm2022/signality-core-reactivity-throttled.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signality-core-reactivity-throttled.mjs","sources":["../../../projects/core/reactivity/throttled/index.ts","../../../projects/core/reactivity/throttled/signality-core-reactivity-throttled.ts"],"sourcesContent":["import {\n  type CreateSignalOptions,\n  isSignal,\n  signal,\n  type Signal,\n  type WritableSignal,\n} from '@angular/core';\nimport { proxySignal, setupContext, toValue } from '@signality/core/internal';\nimport type { MaybeSignal, SignalValue, WithInjector } from '@signality/core/types';\nimport { throttleCallback } from '@signality/core/scheduling/throttle-callback';\nimport { watcher } from '@signality/core/reactivity/watcher';\n\nexport type ThrottledOptions<T> = CreateSignalOptions<T> & WithInjector;\n\n/**\n * Creates a throttled readonly signal from a source signal.\n * Updates to the source signal are throttled to occur at most once per time interval.\n *\n * @param source - Source signal to throttle\n * @param timeMs - Throttle interval in milliseconds\n * @param options - Optional configuration including signal options and injector\n * @returns A readonly signal that updates at most once per throttle interval\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     <div (scroll)=\"scrollY.set($event.target.scrollTop)\">\n *       <p>Scroll position: {{ scrollY() }}</p>\n *       <p>Throttled position: {{ throttledScrollY() }}</p>\n *     </div>\n *   `\n * })\n * class ScrollTracker {\n *   readonly scrollY = signal(0);\n *   readonly throttledScrollY = throttled(this.scrollY, 100);\n * }\n * ```\n */\nexport function throttled<S extends Signal<any>>(\n  source: S,\n  timeMs: MaybeSignal<number>,\n  options?: ThrottledOptions<SignalValue<S>>\n): Signal<SignalValue<S>>;\n\n/**\n * Creates a throttled writable signal from an initial value.\n * Both `set()` and `update()` calls are throttled.\n *\n * @param value - Initial value\n * @param timeMs - Throttle interval in milliseconds\n * @param options - Optional configuration including signal options and injector\n * @returns A writable signal where updates are throttled\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     <div (mousemove)=\"mousePosition.set({ x: $event.clientX, y: $event.clientY })\">\n *       <p>Mouse position: X={{ mousePosition().x }}, Y={{ mousePosition().y }}</p>\n *     </div>\n *   `\n * })\n * class MouseTracker {\n *   readonly mousePosition = throttled({ x: 0, y: 0 }, 16);\n * }\n * ```\n */\nexport function throttled<V>(\n  value: V,\n  timeMs: MaybeSignal<number>,\n  options?: ThrottledOptions<V>\n): WritableSignal<V>;\n\nexport function throttled(\n  valueOrSignal: any,\n  timeMs: MaybeSignal<number>,\n  options?: ThrottledOptions<any>\n) {\n  const { runInContext } = setupContext(options?.injector, throttled);\n\n  return runInContext(() => {\n    const initialValue = toValue(valueOrSignal);\n    const output = signal(initialValue, options);\n    const set = throttleCallback(output.set, timeMs);\n\n    if (isSignal(valueOrSignal)) {\n      watcher(valueOrSignal, set);\n      return output.asReadonly();\n    } else {\n      return proxySignal(output, { set });\n    }\n  });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;;;SA0EgB,SAAS,CACvB,aAAkB,EAClB,MAA2B,EAC3B,OAA+B,EAAA;AAE/B,IAAA,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,SAAS,CAAC;IAEnE,OAAO,YAAY,CAAC,MAAK;AACvB,QAAA,MAAM,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;QAC3C,MAAM,MAAM,GAAG,MAAM,CAAC,YAAY,EAAE,OAAO,CAAC;QAC5C,MAAM,GAAG,GAAG,gBAAgB,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC;AAEhD,QAAA,IAAI,QAAQ,CAAC,aAAa,CAAC,EAAE;AAC3B,YAAA,OAAO,CAAC,aAAa,EAAE,GAAG,CAAC;AAC3B,YAAA,OAAO,MAAM,CAAC,UAAU,EAAE;QAC5B;aAAO;YACL,OAAO,WAAW,CAAC,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC;QACrC;AACF,IAAA,CAAC,CAAC;AACJ;;AC7FA;;AAEG;;;;"}

package/fesm2022/signality-core-reactivity-watcher.mjs

@@ -0,0 +1,36 @@
+import { effect, untracked } from '@angular/core';
+import { setupContext } from '@signality/core/internal';
+
+function watcher(sourceOrSources, fn, options) {
+    const { runInContext } = setupContext(options?.injector, watcher);
+    return runInContext(() => {
+        const isArray = Array.isArray(sourceOrSources);
+        const deps = isArray ? sourceOrSources : [sourceOrSources];
+        const once = options?.once ?? false;
+        let isFirstRun = true;
+        let prevValues = null;
+        const effectRef = effect(onCleanup => {
+            const currValues = deps.map(track => track());
+            if (isFirstRun) {
+                isFirstRun = false;
+                prevValues = currValues;
+                return;
+            }
+            const currentValue = isArray ? currValues : currValues[0];
+            const previousValue = isArray ? prevValues : prevValues?.[0];
+            prevValues = currValues;
+            untracked(() => fn(currentValue, previousValue, onCleanup));
+            if (once) {
+                effectRef.destroy();
+            }
+        }, options);
+        return effectRef;
+    });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { watcher };
+//# sourceMappingURL=signality-core-reactivity-watcher.mjs.map

package/fesm2022/signality-core-reactivity-watcher.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signality-core-reactivity-watcher.mjs","sources":["../../../projects/core/reactivity/watcher/index.ts","../../../projects/core/reactivity/watcher/signality-core-reactivity-watcher.ts"],"sourcesContent":["import {\n  type CreateEffectOptions,\n  effect,\n  type EffectCleanupRegisterFn,\n  type EffectRef,\n  type Signal,\n  untracked,\n} from '@angular/core';\nimport { setupContext } from '@signality/core/internal';\nimport type { SignalValues } from '@signality/core/types';\n\nexport interface CreateWatcherOptions extends Omit<CreateEffectOptions, 'allowSignalWrites'> {\n  /**\n   * If `true`, the watcher will automatically destroy itself after the first change.\n   * @default false\n   */\n  readonly once?: boolean;\n}\n\nexport type WatcherRef = EffectRef;\n\n/**\n * Watches a single signal and calls a callback when it changes, skipping the initial call.\n * Unlike `effect()`, this responds to the fact of state change, enabling event-like orchestration of side effects.\n *\n * @param source - Signal to watch\n * @param fn - Callback function called when signal changes. Receives current value, previous value, and cleanup function\n * @param options - Optional configuration including effect options and injector\n * @returns A WatcherRef (alias for EffectRef) that can be used to manually destroy the watcher\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     <button (click)=\"count.set(count() + 1)\">Count: {{ count() }}</button>\n *   `\n * })\n * class CounterComponent {\n *   readonly count = signal(0);\n *\n *   constructor() {\n *     watcher(this.count, (curr, prev) => {\n *       console.log('Count changed from', prev, 'to', curr);\n *     });\n *   }\n * }\n * ```\n */\nexport function watcher<V>(\n  source: Signal<V>,\n  fn: (curr: V, prev: V, onCleanup: EffectCleanupRegisterFn) => void,\n  options?: CreateWatcherOptions\n): WatcherRef;\n\n/**\n * Watches multiple signals and calls a callback when any of them changes, skipping the initial call.\n * Unlike `effect()`, this responds to the fact of state change, enabling event-like orchestration of side effects.\n *\n * @param sources - Array of signals to watch\n * @param fn - Callback function called when any signal changes. Receives current values array, previous values array, and cleanup function\n * @param options - Optional configuration including effect options and injector\n * @returns A WatcherRef (alias for EffectRef) that can be used to manually destroy the watcher\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     <input [(ngModel)]=\"name\" />\n *     <input [(ngModel)]=\"age\" type=\"number\" />\n *   `\n * })\n * class UserComponent {\n *   readonly name = signal('John');\n *   readonly age = signal(25);\n *\n *   constructor() {\n *     watcher([this.name, this.age], ([name, age], [prevName, prevAge]) => {\n *       console.log('User changed:', { name, age });\n *     });\n *   }\n * }\n * ```\n */\nexport function watcher<T extends readonly Signal<any>[]>(\n  sources: T,\n  fn: (curr: SignalValues<T>, prev: SignalValues<T>, onCleanup: EffectCleanupRegisterFn) => void,\n  options?: CreateWatcherOptions\n): WatcherRef;\n\nexport function watcher<V, T extends readonly Signal<any>[]>(\n  sourceOrSources: Signal<V> | T,\n  fn:\n    | ((curr: V, prev: V, onCleanup: EffectCleanupRegisterFn) => void)\n    | ((curr: SignalValues<T>, prev: SignalValues<T>, onCleanup: EffectCleanupRegisterFn) => void),\n  options?: CreateWatcherOptions\n): WatcherRef {\n  const { runInContext } = setupContext(options?.injector, watcher);\n\n  return runInContext(() => {\n    const isArray = Array.isArray(sourceOrSources);\n    const deps = isArray ? (sourceOrSources as Signal<any>[]) : [sourceOrSources as Signal<V>];\n    const once = options?.once ?? false;\n\n    let isFirstRun = true;\n    let prevValues: readonly any[] | null = null;\n\n    const effectRef = effect(onCleanup => {\n      const currValues = deps.map(track => track());\n\n      if (isFirstRun) {\n        isFirstRun = false;\n        prevValues = currValues;\n        return;\n      }\n\n      const currentValue = isArray ? currValues : currValues[0];\n      const previousValue = isArray ? prevValues : prevValues?.[0];\n\n      prevValues = currValues;\n\n      untracked(() => fn(currentValue, previousValue, onCleanup));\n\n      if (once) {\n        effectRef.destroy();\n      }\n    }, options);\n\n    return effectRef;\n  });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;SAyFgB,OAAO,CACrB,eAA8B,EAC9B,EAEgG,EAChG,OAA8B,EAAA;AAE9B,IAAA,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC;IAEjE,OAAO,YAAY,CAAC,MAAK;QACvB,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,eAAe,CAAC;AAC9C,QAAA,MAAM,IAAI,GAAG,OAAO,GAAI,eAAiC,GAAG,CAAC,eAA4B,CAAC;AAC1F,QAAA,MAAM,IAAI,GAAG,OAAO,EAAE,IAAI,IAAI,KAAK;QAEnC,IAAI,UAAU,GAAG,IAAI;QACrB,IAAI,UAAU,GAA0B,IAAI;AAE5C,QAAA,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAG;AACnC,YAAA,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,IAAI,KAAK,EAAE,CAAC;YAE7C,IAAI,UAAU,EAAE;gBACd,UAAU,GAAG,KAAK;gBAClB,UAAU,GAAG,UAAU;gBACvB;YACF;AAEA,YAAA,MAAM,YAAY,GAAG,OAAO,GAAG,UAAU,GAAG,UAAU,CAAC,CAAC,CAAC;AACzD,YAAA,MAAM,aAAa,GAAG,OAAO,GAAG,UAAU,GAAG,UAAU,GAAG,CAAC,CAAC;YAE5D,UAAU,GAAG,UAAU;AAEvB,YAAA,SAAS,CAAC,MAAM,EAAE,CAAC,YAAY,EAAE,aAAa,EAAE,SAAS,CAAC,CAAC;YAE3D,IAAI,IAAI,EAAE;gBACR,SAAS,CAAC,OAAO,EAAE;YACrB;QACF,CAAC,EAAE,OAAO,CAAC;AAEX,QAAA,OAAO,SAAS;AAClB,IAAA,CAAC,CAAC;AACJ;;ACjIA;;AAEG;;;;"}

package/fesm2022/signality-core-reactivity.mjs

@@ -0,0 +1,8 @@
+export * from '@signality/core/reactivity/debounced';
+export * from '@signality/core/reactivity/throttled';
+export * from '@signality/core/reactivity/watcher';
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+//# sourceMappingURL=signality-core-reactivity.mjs.map

package/fesm2022/signality-core-reactivity.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signality-core-reactivity.mjs","sources":["../../../projects/core/reactivity/signality-core-reactivity.ts"],"sourcesContent":["/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;;AAAA;;AAEG"}

package/fesm2022/signality-core-router-fragment.mjs

@@ -0,0 +1,41 @@
+import { inject } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { setupContext } from '@signality/core/internal';
+
+/**
+ * Reactive wrapper around the [Angular Router](https://angular.dev/guide/routing) URL fragment.
+ *
+ * @param options - Optional configuration including signal options and injector
+ * @returns A signal containing the current URL fragment (without #), or null
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     @if (currentFragment(); as fragment) {
+ *       <p>Current section: {{ fragment }}</p>
+ *     } @else {
+ *       <p>No fragment in URL</p>
+ *     }
+ *   `
+ * })
+ * class FragmentComponent {
+ *   readonly currentFragment = fragment();
+ * }
+ * ```
+ */
+function fragment(options) {
+    const { runInContext } = setupContext(options?.injector, fragment);
+    return runInContext(() => {
+        const { fragment: fragmentChanges, snapshot } = inject(ActivatedRoute);
+        return toSignal(fragmentChanges, { ...options, initialValue: snapshot.fragment });
+    });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { fragment };
+//# sourceMappingURL=signality-core-router-fragment.mjs.map

package/fesm2022/signality-core-router-fragment.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signality-core-router-fragment.mjs","sources":["../../../projects/core/router/fragment/index.ts","../../../projects/core/router/fragment/signality-core-router-fragment.ts"],"sourcesContent":["import { type CreateSignalOptions, inject, type Signal } from '@angular/core';\nimport { ActivatedRoute } from '@angular/router';\nimport { toSignal } from '@angular/core/rxjs-interop';\nimport { setupContext } from '@signality/core/internal';\nimport type { WithInjector } from '@signality/core/types';\n\nexport type FragmentOptions = CreateSignalOptions<string | null> & WithInjector;\n\n/**\n * Reactive wrapper around the [Angular Router](https://angular.dev/guide/routing) URL fragment.\n *\n * @param options - Optional configuration including signal options and injector\n * @returns A signal containing the current URL fragment (without #), or null\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     @if (currentFragment(); as fragment) {\n *       <p>Current section: {{ fragment }}</p>\n *     } @else {\n *       <p>No fragment in URL</p>\n *     }\n *   `\n * })\n * class FragmentComponent {\n *   readonly currentFragment = fragment();\n * }\n * ```\n */\nexport function fragment(options?: FragmentOptions): Signal<string | null> {\n  const { runInContext } = setupContext(options?.injector, fragment);\n\n  return runInContext(() => {\n    const { fragment: fragmentChanges, snapshot } = inject(ActivatedRoute);\n\n    return toSignal(fragmentChanges, { ...options, initialValue: snapshot.fragment });\n  });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;;;AAQA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACG,SAAU,QAAQ,CAAC,OAAyB,EAAA;AAChD,IAAA,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC;IAElE,OAAO,YAAY,CAAC,MAAK;AACvB,QAAA,MAAM,EAAE,QAAQ,EAAE,eAAe,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC,cAAc,CAAC;AAEtE,QAAA,OAAO,QAAQ,CAAC,eAAe,EAAE,EAAE,GAAG,OAAO,EAAE,YAAY,EAAE,QAAQ,CAAC,QAAQ,EAAE,CAAC;AACnF,IAAA,CAAC,CAAC;AACJ;;ACtCA;;AAEG;;;;"}

package/fesm2022/signality-core-router-params.mjs

@@ -0,0 +1,45 @@
+import { inject } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { setupContext } from '@signality/core/internal';
+
+/**
+ * Reactive wrapper around Angular Router's route parameters.
+ * Access route parameters as a signal that updates when navigation occurs.
+ *
+ * @param options - Optional configuration including signal options and injector
+ * @returns A signal containing the current route parameters
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     <div>
+ *       <p>User ID: {{ routeParams().id }}</p>
+ *       <p>Slug: {{ routeParams().slug }}</p>
+ *     </div>
+ *   `
+ * })
+ * class UserComponent {
+ *   // Route: /user/:id/:slug
+ *   readonly routeParams = params<{ id: string; slug: string }>();
+ * }
+ * ```
+ */
+function params(options) {
+    const { runInContext } = setupContext(options?.injector, params);
+    return runInContext(() => {
+        const { params: paramsChanges, snapshot } = inject(ActivatedRoute);
+        return toSignal(paramsChanges, {
+            ...options,
+            initialValue: snapshot.params,
+        });
+    });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { params };
+//# sourceMappingURL=signality-core-router-params.mjs.map

package/fesm2022/signality-core-router-params.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signality-core-router-params.mjs","sources":["../../../projects/core/router/params/index.ts","../../../projects/core/router/params/signality-core-router-params.ts"],"sourcesContent":["import { type CreateSignalOptions, inject, type Signal } from '@angular/core';\nimport { ActivatedRoute, type Params } from '@angular/router';\nimport { toSignal } from '@angular/core/rxjs-interop';\nimport type { Observable } from 'rxjs';\nimport { setupContext } from '@signality/core/internal';\nimport type { WithInjector } from '@signality/core/types';\n\nexport type ParamsOptions<T extends Params = Params> = CreateSignalOptions<T> & WithInjector;\n\n/**\n * Reactive wrapper around Angular Router's route parameters.\n * Access route parameters as a signal that updates when navigation occurs.\n *\n * @param options - Optional configuration including signal options and injector\n * @returns A signal containing the current route parameters\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     <div>\n *       <p>User ID: {{ routeParams().id }}</p>\n *       <p>Slug: {{ routeParams().slug }}</p>\n *     </div>\n *   `\n * })\n * class UserComponent {\n *   // Route: /user/:id/:slug\n *   readonly routeParams = params<{ id: string; slug: string }>();\n * }\n * ```\n */\nexport function params<T extends Params = Params>(options?: ParamsOptions<T>): Signal<T> {\n  const { runInContext } = setupContext(options?.injector, params);\n\n  return runInContext(() => {\n    const { params: paramsChanges, snapshot } = inject(ActivatedRoute);\n\n    return toSignal<T, T>(paramsChanges as Observable<T>, {\n      ...options,\n      initialValue: snapshot.params as T,\n    });\n  });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;;;AASA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,MAAM,CAA4B,OAA0B,EAAA;AAC1E,IAAA,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC;IAEhE,OAAO,YAAY,CAAC,MAAK;AACvB,QAAA,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC,cAAc,CAAC;QAElE,OAAO,QAAQ,CAAO,aAA8B,EAAE;AACpD,YAAA,GAAG,OAAO;YACV,YAAY,EAAE,QAAQ,CAAC,MAAW;AACnC,SAAA,CAAC;AACJ,IAAA,CAAC,CAAC;AACJ;;AC3CA;;AAEG;;;;"}

package/fesm2022/signality-core-router-query-params.mjs

@@ -0,0 +1,67 @@
+import { inject, signal, computed } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { map } from 'rxjs';
+import { setupContext } from '@signality/core/internal';
+
+function queryParams(options) {
+    const { runInContext } = setupContext(options?.injector, queryParams);
+    return runInContext(() => {
+        const { queryParams: paramsChanges, snapshot } = inject(ActivatedRoute);
+        const hasSchema = options && 'schema' in options && options.schema !== undefined;
+        if (!hasSchema) {
+            return toSignal(paramsChanges, {
+                ...options,
+                initialValue: snapshot.queryParams,
+            });
+        }
+        const schema = options.schema;
+        const initialRaw = snapshot.queryParams;
+        let initialValue = null;
+        let initialError = null;
+        try {
+            initialValue = schema.parse(initialRaw);
+        }
+        catch (err) {
+            initialError = err;
+        }
+        const error = signal(initialError, ...(ngDevMode ? [{ debugName: "error" }] : []));
+        const isValid = signal(!initialError, ...(ngDevMode ? [{ debugName: "isValid" }] : []));
+        const validatedValue = toSignal(paramsChanges.pipe(map(rawParams => {
+            try {
+                const parsed = schema.parse(rawParams);
+                isValid.set(true);
+                error.set(null);
+                return parsed;
+            }
+            catch (err) {
+                isValid.set(false);
+                error.set(err);
+                return null;
+            }
+        })), { initialValue });
+        const value = computed(() => {
+            const validated = validatedValue();
+            const err = error();
+            if (err !== null) {
+                throw err;
+            }
+            return validated;
+        }, {
+            ...options,
+            debugName: options.debugName ? `${options.debugName}.value` : undefined,
+        });
+        return {
+            value,
+            isValid: isValid.asReadonly(),
+            error: error.asReadonly(),
+        };
+    });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { queryParams };
+//# sourceMappingURL=signality-core-router-query-params.mjs.map

package/fesm2022/signality-core-router-query-params.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signality-core-router-query-params.mjs","sources":["../../../projects/core/router/query-params/index.ts","../../../projects/core/router/query-params/signality-core-router-query-params.ts"],"sourcesContent":["import { computed, type CreateSignalOptions, inject, signal, type Signal } from '@angular/core';\nimport { ActivatedRoute, type Params } from '@angular/router';\nimport { toSignal } from '@angular/core/rxjs-interop';\nimport { map, type Observable } from 'rxjs';\nimport { setupContext } from '@signality/core/internal';\nimport type { WithInjector } from '@signality/core/types';\n\nexport interface QueryParamsValidator<T> {\n  /**\n   * Parse and validate data, throwing an error if validation fails.\n   */\n  parse(data: unknown): T;\n}\n\nexport interface QueryParamsRef<T> {\n  /**\n   * Signal containing validated query parameters.\n   * Throws an error if validation failed. Use `isValid()` to check before reading.\n   */\n  readonly value: Signal<T>;\n\n  /**\n   * Signal indicating whether the current query parameters are valid.\n   * Returns `true` when validation succeeded, `false` when validation failed.\n   */\n  readonly isValid: Signal<boolean>;\n\n  /** Signal containing validation error, or null if valid */\n  readonly error: Signal<unknown | null>;\n}\n\nexport type QueryParamsOptions<T extends Params = Params> = CreateSignalOptions<T> & WithInjector;\n\nexport type QueryParamsWithSchemaOptions<T extends Params = Params> = QueryParamsOptions<T> & {\n  /** Validator schema (e.g., Zod schema) */\n  readonly schema: QueryParamsValidator<T>;\n};\n\n/**\n * Reactive wrapper around the [Angular Router](https://angular.dev/guide/routing) query parameters.\n *\n * @param options - Optional configuration including signal options and injector\n * @returns A signal containing the current query parameters\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     <div>\n *       <p>Search: {{ searchParams().q }}</p>\n *       <p>Sort: {{ searchParams().sort }}</p>\n *     </div>\n *   `\n * })\n * class SearchComponent {\n *   // Route: /search?q=angular&sort=name\n *   readonly searchParams = queryParams<{ q: string; sort: string }>();\n * }\n * ```\n */\nexport function queryParams<T extends Params = Params>(options?: QueryParamsOptions<T>): Signal<T>;\n\n/**\n * Reactive wrapper around the [Angular Router](https://angular.dev/guide/routing) query parameters with schema validation.\n *\n * @param options - Configuration including schema validator\n * @returns A QueryParamsRef object with value, isValid, and error signals\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     @if (params.isValid()) {\n *       <p>Search: {{ params.value().q }}</p>\n *       <p>Page: {{ params.value().page }}</p>\n *     } @else {\n *       <p>Invalid parameters</p>\n *     }\n *   `\n * })\n * class ValidatedSearchComponent {\n *   readonly schema = z.object({\n *     q: z.string().min(1).optional(),\n *     page: z.coerce.number().int().positive().default(1),\n *   });\n *\n *   readonly params = queryParams({ schema: this.schema });\n * }\n * ```\n */\nexport function queryParams<T extends Params = Params>(\n  options: QueryParamsWithSchemaOptions<T>\n): QueryParamsRef<T>;\n\nexport function queryParams<T extends Params = Params>(\n  options?: QueryParamsOptions<T> | QueryParamsWithSchemaOptions<T>\n): Signal<T> | QueryParamsRef<T> {\n  const { runInContext } = setupContext(options?.injector, queryParams);\n\n  return runInContext(() => {\n    const { queryParams: paramsChanges, snapshot } = inject(ActivatedRoute);\n    const hasSchema = options && 'schema' in options && options.schema !== undefined;\n\n    if (!hasSchema) {\n      return toSignal<T, T>(paramsChanges as Observable<T>, {\n        ...options,\n        initialValue: snapshot.queryParams as T,\n      });\n    }\n\n    const schema = options.schema;\n    const initialRaw = snapshot.queryParams as T;\n\n    let initialValue: T | null = null;\n    let initialError: unknown | null = null;\n\n    try {\n      initialValue = schema.parse(initialRaw);\n    } catch (err) {\n      initialError = err;\n    }\n\n    const error = signal<unknown | null>(initialError);\n    const isValid = signal(!initialError);\n\n    const validatedValue = toSignal<T | null, T | null>(\n      paramsChanges.pipe(\n        map(rawParams => {\n          try {\n            const parsed = schema.parse(rawParams);\n            isValid.set(true);\n            error.set(null);\n            return parsed;\n          } catch (err) {\n            isValid.set(false);\n            error.set(err);\n            return null;\n          }\n        })\n      ),\n      { initialValue }\n    );\n\n    const value = computed(\n      () => {\n        const validated = validatedValue();\n        const err = error();\n\n        if (err !== null) {\n          throw err;\n        }\n\n        return validated!;\n      },\n      {\n        ...options,\n        debugName: options.debugName ? `${options.debugName}.value` : undefined,\n      }\n    );\n\n    return {\n      value,\n      isValid: isValid.asReadonly(),\n      error: error.asReadonly(),\n    };\n  });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;;;;AA8FM,SAAU,WAAW,CACzB,OAAiE,EAAA;AAEjE,IAAA,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,WAAW,CAAC;IAErE,OAAO,YAAY,CAAC,MAAK;AACvB,QAAA,MAAM,EAAE,WAAW,EAAE,aAAa,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC,cAAc,CAAC;AACvE,QAAA,MAAM,SAAS,GAAG,OAAO,IAAI,QAAQ,IAAI,OAAO,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS;QAEhF,IAAI,CAAC,SAAS,EAAE;YACd,OAAO,QAAQ,CAAO,aAA8B,EAAE;AACpD,gBAAA,GAAG,OAAO;gBACV,YAAY,EAAE,QAAQ,CAAC,WAAgB;AACxC,aAAA,CAAC;QACJ;AAEA,QAAA,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM;AAC7B,QAAA,MAAM,UAAU,GAAG,QAAQ,CAAC,WAAgB;QAE5C,IAAI,YAAY,GAAa,IAAI;QACjC,IAAI,YAAY,GAAmB,IAAI;AAEvC,QAAA,IAAI;AACF,YAAA,YAAY,GAAG,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC;QACzC;QAAE,OAAO,GAAG,EAAE;YACZ,YAAY,GAAG,GAAG;QACpB;AAEA,QAAA,MAAM,KAAK,GAAG,MAAM,CAAiB,YAAY,iDAAC;AAClD,QAAA,MAAM,OAAO,GAAG,MAAM,CAAC,CAAC,YAAY,mDAAC;AAErC,QAAA,MAAM,cAAc,GAAG,QAAQ,CAC7B,aAAa,CAAC,IAAI,CAChB,GAAG,CAAC,SAAS,IAAG;AACd,YAAA,IAAI;gBACF,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC;AACtC,gBAAA,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;AACjB,gBAAA,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC;AACf,gBAAA,OAAO,MAAM;YACf;YAAE,OAAO,GAAG,EAAE;AACZ,gBAAA,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC;AAClB,gBAAA,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC;AACd,gBAAA,OAAO,IAAI;YACb;AACF,QAAA,CAAC,CAAC,CACH,EACD,EAAE,YAAY,EAAE,CACjB;AAED,QAAA,MAAM,KAAK,GAAG,QAAQ,CACpB,MAAK;AACH,YAAA,MAAM,SAAS,GAAG,cAAc,EAAE;AAClC,YAAA,MAAM,GAAG,GAAG,KAAK,EAAE;AAEnB,YAAA,IAAI,GAAG,KAAK,IAAI,EAAE;AAChB,gBAAA,MAAM,GAAG;YACX;AAEA,YAAA,OAAO,SAAU;AACnB,QAAA,CAAC,EACD;AACE,YAAA,GAAG,OAAO;AACV,YAAA,SAAS,EAAE,OAAO,CAAC,SAAS,GAAG,CAAA,EAAG,OAAO,CAAC,SAAS,CAAA,MAAA,CAAQ,GAAG,SAAS;AACxE,SAAA,CACF;QAED,OAAO;YACL,KAAK;AACL,YAAA,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE;AAC7B,YAAA,KAAK,EAAE,KAAK,CAAC,UAAU,EAAE;SAC1B;AACH,IAAA,CAAC,CAAC;AACJ;;ACtKA;;AAEG;;;;"}

package/fesm2022/signality-core-router-route-data.mjs

@@ -0,0 +1,46 @@
+import { inject } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { setupContext } from '@signality/core/internal';
+
+/**
+ * Reactive wrapper around the [Angular Router](https://angular.dev/guide/routing) route data.
+ *
+ * @param options - Optional configuration including signal options and injector
+ * @returns A signal containing the current route data
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     <div>
+ *       <h1>{{ data().name }}</h1>
+ *       @if (data().showBreadcrumbs) {
+ *         <nav>Breadcrumbs here</nav>
+ *       }
+ *     </div>
+ *   `
+ * })
+ * class ProductComponent {
+ *   // Route with data: { name: 'Product Page', showBreadcrumbs: true }
+ *   readonly data = routeData<{ name: string; showBreadcrumbs: boolean }>();
+ * }
+ * ```
+ */
+function routeData(options) {
+    const { runInContext } = setupContext(options?.injector, routeData);
+    return runInContext(() => {
+        const { data, snapshot } = inject(ActivatedRoute);
+        return toSignal(data, {
+            ...options,
+            initialValue: snapshot.data,
+        });
+    });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { routeData };
+//# sourceMappingURL=signality-core-router-route-data.mjs.map

package/fesm2022/signality-core-router-route-data.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signality-core-router-route-data.mjs","sources":["../../../projects/core/router/route-data/index.ts","../../../projects/core/router/route-data/signality-core-router-route-data.ts"],"sourcesContent":["import { type CreateSignalOptions, inject, type Signal } from '@angular/core';\nimport { ActivatedRoute } from '@angular/router';\nimport { toSignal } from '@angular/core/rxjs-interop';\nimport type { Observable } from 'rxjs';\nimport { setupContext } from '@signality/core/internal';\nimport type { WithInjector } from '@signality/core/types';\n\nexport type RouteDataOptions<T = unknown> = CreateSignalOptions<T> & WithInjector;\n\n/**\n * Reactive wrapper around the [Angular Router](https://angular.dev/guide/routing) route data.\n *\n * @param options - Optional configuration including signal options and injector\n * @returns A signal containing the current route data\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     <div>\n *       <h1>{{ data().name }}</h1>\n *       @if (data().showBreadcrumbs) {\n *         <nav>Breadcrumbs here</nav>\n *       }\n *     </div>\n *   `\n * })\n * class ProductComponent {\n *   // Route with data: { name: 'Product Page', showBreadcrumbs: true }\n *   readonly data = routeData<{ name: string; showBreadcrumbs: boolean }>();\n * }\n * ```\n */\nexport function routeData<T = unknown>(options?: RouteDataOptions<T>): Signal<T> {\n  const { runInContext } = setupContext(options?.injector, routeData);\n\n  return runInContext(() => {\n    const { data, snapshot } = inject(ActivatedRoute);\n\n    return toSignal<T, T>(data as Observable<T>, {\n      ...options,\n      initialValue: snapshot.data as T,\n    });\n  });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;;;AASA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACG,SAAU,SAAS,CAAc,OAA6B,EAAA;AAClE,IAAA,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,SAAS,CAAC;IAEnE,OAAO,YAAY,CAAC,MAAK;QACvB,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC,cAAc,CAAC;QAEjD,OAAO,QAAQ,CAAO,IAAqB,EAAE;AAC3C,YAAA,GAAG,OAAO;YACV,YAAY,EAAE,QAAQ,CAAC,IAAS;AACjC,SAAA,CAAC;AACJ,IAAA,CAAC,CAAC;AACJ;;AC5CA;;AAEG;;;;"}