@signality/core 0.0.1-alpha.2

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

@@ -0,0 +1,50 @@
+import { inject } from '@angular/core';
+import { Router, Scroll, ActivationEnd, ActivationStart, ChildActivationEnd, ChildActivationStart, RouteConfigLoadEnd, RouteConfigLoadStart, ResolveEnd, ResolveStart, GuardsCheckEnd, GuardsCheckStart, RoutesRecognized, NavigationSkipped, NavigationError, NavigationCancel, NavigationEnd, NavigationStart } from '@angular/router';
+import { filter } from 'rxjs';
+import { setupContext } from '@signality/core/internal';
+
+function routerListener(event, handler, options) {
+    const { runInContext } = setupContext(options?.injector, routerListener);
+    return runInContext(({ onCleanup }) => {
+        const router = inject(Router);
+        const events = Array.isArray(event) ? event : [event];
+        const EventClasses = events.map((e) => EVENT_CLASSES[e]);
+        const subscription = router.events
+            .pipe(filter((routerEvent) => EventClasses.some(EventClass => routerEvent instanceof EventClass)))
+            .subscribe(e => {
+            handler(e);
+            if (options?.once) {
+                subscription.unsubscribe();
+            }
+        });
+        const destroy = subscription.unsubscribe.bind(subscription);
+        onCleanup(destroy);
+        return { destroy };
+    });
+}
+const EVENT_CLASSES = {
+    navigationstart: NavigationStart,
+    navigationend: NavigationEnd,
+    navigationcancel: NavigationCancel,
+    navigationerror: NavigationError,
+    navigationskipped: NavigationSkipped,
+    routesrecognized: RoutesRecognized,
+    guardscheckstart: GuardsCheckStart,
+    guardscheckend: GuardsCheckEnd,
+    resolvestart: ResolveStart,
+    resolveend: ResolveEnd,
+    routeconfigloadstart: RouteConfigLoadStart,
+    routeconfigloadend: RouteConfigLoadEnd,
+    childactivationstart: ChildActivationStart,
+    childactivationend: ChildActivationEnd,
+    activationstart: ActivationStart,
+    activationend: ActivationEnd,
+    scroll: Scroll,
+};
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { routerListener };
+//# sourceMappingURL=signality-core-router-router-listener.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"signality-core-router-router-listener.mjs","sources":["../../../projects/core/router/router-listener/index.ts","../../../projects/core/router/router-listener/signality-core-router-router-listener.ts"],"sourcesContent":["import { inject } from '@angular/core';\nimport {\n  ActivationEnd,\n  ActivationStart,\n  ChildActivationEnd,\n  ChildActivationStart,\n  type Event as RouterEvent,\n  GuardsCheckEnd,\n  GuardsCheckStart,\n  NavigationCancel,\n  NavigationEnd,\n  NavigationError,\n  NavigationSkipped,\n  NavigationStart,\n  ResolveEnd,\n  ResolveStart,\n  RouteConfigLoadEnd,\n  RouteConfigLoadStart,\n  Router,\n  RoutesRecognized,\n  Scroll,\n} from '@angular/router';\nimport { filter } from 'rxjs';\nimport { setupContext } from '@signality/core/internal';\nimport type { WithInjector } from '@signality/core/types';\n\nexport interface RouterListenerOptions extends WithInjector {\n  /** If true, automatically unsubscribe after the first event */\n  readonly once?: boolean;\n}\n\nexport interface RouterListenerRef {\n  /** Manually unsubscribe from router events */\n  readonly destroy: () => void;\n}\n\nexport type RouterEventType =\n  | 'navigationstart'\n  | 'navigationend'\n  | 'navigationcancel'\n  | 'navigationerror'\n  | 'navigationskipped'\n  | 'routesrecognized'\n  | 'guardscheckstart'\n  | 'guardscheckend'\n  | 'resolvestart'\n  | 'resolveend'\n  | 'routeconfigloadstart'\n  | 'routeconfigloadend'\n  | 'childactivationstart'\n  | 'childactivationend'\n  | 'activationstart'\n  | 'activationend'\n  | 'scroll';\n\n/**\n * Event-driven listener for [Angular Router](https://angular.dev/guide/routing) events.\n *\n * @param event - Router event name in lowercase (e.g., 'navigationstart') or array of event names\n * @param handler - Type-safe handler function for the specific event(s)\n * @param options - Optional configuration\n * @returns RouterListenerRef with destroy method for manual unsubscribe\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     @if (isLoading()) {\n *       <p>Navigation in progress...</p>\n *     }\n *   `\n * })\n * class NavigationComponent {\n *   readonly isLoading = signal(false);\n *\n *   constructor() {\n *     routerListener('navigationstart', event => {\n *       this.isLoading.set(true);\n *     });\n *\n *     routerListener('navigationend', event => {\n *       this.isLoading.set(false);\n *     });\n *   }\n * }\n * ```\n */\nexport function routerListener(\n  event: 'navigationstart',\n  handler: (event: NavigationStart) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef;\nexport function routerListener(\n  event: 'navigationend',\n  handler: (event: NavigationEnd) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef;\nexport function routerListener(\n  event: 'navigationcancel',\n  handler: (event: NavigationCancel) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef;\nexport function routerListener(\n  event: 'navigationerror',\n  handler: (event: NavigationError) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef;\nexport function routerListener(\n  event: 'navigationskipped',\n  handler: (event: NavigationSkipped) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef;\nexport function routerListener(\n  event: 'routesrecognized',\n  handler: (event: RoutesRecognized) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef;\nexport function routerListener(\n  event: 'guardscheckstart',\n  handler: (event: GuardsCheckStart) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef;\nexport function routerListener(\n  event: 'guardscheckend',\n  handler: (event: GuardsCheckEnd) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef;\nexport function routerListener(\n  event: 'resolvestart',\n  handler: (event: ResolveStart) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef;\nexport function routerListener(\n  event: 'resolveend',\n  handler: (event: ResolveEnd) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef;\nexport function routerListener(\n  event: 'routeconfigloadstart',\n  handler: (event: RouteConfigLoadStart) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef;\nexport function routerListener(\n  event: 'routeconfigloadend',\n  handler: (event: RouteConfigLoadEnd) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef;\nexport function routerListener(\n  event: 'childactivationstart',\n  handler: (event: ChildActivationStart) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef;\nexport function routerListener(\n  event: 'childactivationend',\n  handler: (event: ChildActivationEnd) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef;\nexport function routerListener(\n  event: 'activationstart',\n  handler: (event: ActivationStart) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef;\nexport function routerListener(\n  event: 'activationend',\n  handler: (event: ActivationEnd) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef;\nexport function routerListener(\n  event: 'scroll',\n  handler: (event: Scroll) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef;\nexport function routerListener<T extends readonly [RouterEventType, ...RouterEventType[]]>(\n  events: T,\n  handler: (event: RouterEventTypeArrayToUnion<T>) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef;\nexport function routerListener(\n  event: RouterEventType | readonly RouterEventType[],\n  handler: (event: any) => void,\n  options?: RouterListenerOptions\n): RouterListenerRef {\n  const { runInContext } = setupContext(options?.injector, routerListener);\n\n  return runInContext(({ onCleanup }) => {\n    const router = inject(Router);\n    const events = Array.isArray(event) ? event : [event];\n    const EventClasses = events.map(\n      (e): new (...args: any[]) => RouterEvent => EVENT_CLASSES[e as RouterEventType]\n    );\n\n    const subscription = router.events\n      .pipe(\n        filter((routerEvent: RouterEvent): routerEvent is RouterEvent =>\n          EventClasses.some(EventClass => routerEvent instanceof EventClass)\n        )\n      )\n      .subscribe(e => {\n        handler(e);\n\n        if (options?.once) {\n          subscription.unsubscribe();\n        }\n      });\n\n    const destroy = subscription.unsubscribe.bind(subscription);\n\n    onCleanup(destroy);\n\n    return { destroy };\n  });\n}\n\nconst EVENT_CLASSES: Record<RouterEventType, new (...args: any[]) => RouterEvent> = {\n  navigationstart: NavigationStart,\n  navigationend: NavigationEnd,\n  navigationcancel: NavigationCancel,\n  navigationerror: NavigationError,\n  navigationskipped: NavigationSkipped,\n  routesrecognized: RoutesRecognized,\n  guardscheckstart: GuardsCheckStart,\n  guardscheckend: GuardsCheckEnd,\n  resolvestart: ResolveStart,\n  resolveend: ResolveEnd,\n  routeconfigloadstart: RouteConfigLoadStart,\n  routeconfigloadend: RouteConfigLoadEnd,\n  childactivationstart: ChildActivationStart,\n  childactivationend: ChildActivationEnd,\n  activationstart: ActivationStart,\n  activationend: ActivationEnd,\n  scroll: Scroll,\n};\n\ntype RouterEventTypeMap = {\n  navigationstart: NavigationStart;\n  navigationend: NavigationEnd;\n  navigationcancel: NavigationCancel;\n  navigationerror: NavigationError;\n  navigationskipped: NavigationSkipped;\n  routesrecognized: RoutesRecognized;\n  guardscheckstart: GuardsCheckStart;\n  guardscheckend: GuardsCheckEnd;\n  resolvestart: ResolveStart;\n  resolveend: ResolveEnd;\n  routeconfigloadstart: RouteConfigLoadStart;\n  routeconfigloadend: RouteConfigLoadEnd;\n  childactivationstart: ChildActivationStart;\n  childactivationend: ChildActivationEnd;\n  activationstart: ActivationStart;\n  activationend: ActivationEnd;\n  scroll: Scroll;\n};\n\ntype RouterEventTypeToEventType<T extends RouterEventType> = RouterEventTypeMap[T];\n\ntype RouterEventTypeArrayToUnion<T extends readonly RouterEventType[]> = T[number] extends infer U\n  ? U extends RouterEventType\n    ? RouterEventTypeToEventType<U>\n    : never\n  : never;\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;;;SAiLgB,cAAc,CAC5B,KAAmD,EACnD,OAA6B,EAC7B,OAA+B,EAAA;AAE/B,IAAA,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,cAAc,CAAC;AAExE,IAAA,OAAO,YAAY,CAAC,CAAC,EAAE,SAAS,EAAE,KAAI;AACpC,QAAA,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC7B,QAAA,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,KAAK,GAAG,CAAC,KAAK,CAAC;AACrD,QAAA,MAAM,YAAY,GAAG,MAAM,CAAC,GAAG,CAC7B,CAAC,CAAC,KAA0C,aAAa,CAAC,CAAoB,CAAC,CAChF;AAED,QAAA,MAAM,YAAY,GAAG,MAAM,CAAC;aACzB,IAAI,CACH,MAAM,CAAC,CAAC,WAAwB,KAC9B,YAAY,CAAC,IAAI,CAAC,UAAU,IAAI,WAAW,YAAY,UAAU,CAAC,CACnE;aAEF,SAAS,CAAC,CAAC,IAAG;YACb,OAAO,CAAC,CAAC,CAAC;AAEV,YAAA,IAAI,OAAO,EAAE,IAAI,EAAE;gBACjB,YAAY,CAAC,WAAW,EAAE;YAC5B;AACF,QAAA,CAAC,CAAC;QAEJ,MAAM,OAAO,GAAG,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC;QAE3D,SAAS,CAAC,OAAO,CAAC;QAElB,OAAO,EAAE,OAAO,EAAE;AACpB,IAAA,CAAC,CAAC;AACJ;AAEA,MAAM,aAAa,GAAiE;AAClF,IAAA,eAAe,EAAE,eAAe;AAChC,IAAA,aAAa,EAAE,aAAa;AAC5B,IAAA,gBAAgB,EAAE,gBAAgB;AAClC,IAAA,eAAe,EAAE,eAAe;AAChC,IAAA,iBAAiB,EAAE,iBAAiB;AACpC,IAAA,gBAAgB,EAAE,gBAAgB;AAClC,IAAA,gBAAgB,EAAE,gBAAgB;AAClC,IAAA,cAAc,EAAE,cAAc;AAC9B,IAAA,YAAY,EAAE,YAAY;AAC1B,IAAA,UAAU,EAAE,UAAU;AACtB,IAAA,oBAAoB,EAAE,oBAAoB;AAC1C,IAAA,kBAAkB,EAAE,kBAAkB;AACtC,IAAA,oBAAoB,EAAE,oBAAoB;AAC1C,IAAA,kBAAkB,EAAE,kBAAkB;AACtC,IAAA,eAAe,EAAE,eAAe;AAChC,IAAA,aAAa,EAAE,aAAa;AAC5B,IAAA,MAAM,EAAE,MAAM;CACf;;ACvOD;;AAEG;;;;"}

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

@@ -0,0 +1,54 @@
+import { inject, linkedSignal } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { Title } from '@angular/platform-browser';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { filter } from 'rxjs';
+import { setupContext, proxySignal } from '@signality/core/internal';
+
+/**
+ * Reactive wrapper around the [Angular Router](https://angular.dev/guide/routing) route title.
+ *
+ * @param options - Optional configuration
+ * @returns A writable signal containing the current route title (string)
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     <div>
+ *       <h1>{{ pageTitle() }}</h1>
+ *       <button (click)="updateTitle()">Update Title</button>
+ *     </div>
+ *   `
+ * })
+ * class PageComponent {
+ *   readonly pageTitle = title();
+ *
+ *   updateTitle() {
+ *     this.pageTitle.set('New Page Title');
+ *   }
+ * }
+ * ```
+ */
+function title(options) {
+    const { runInContext } = setupContext(options?.injector, title);
+    return runInContext(() => {
+        const route = inject(ActivatedRoute);
+        const html = inject(Title);
+        return proxySignal(linkedSignal(toSignal(route.title.pipe(filter(Boolean)), {
+            initialValue: route.snapshot.title || html.getTitle(),
+        }), { ...options }), {
+            set: (value, source) => {
+                html.setTitle(value);
+                source.set(value);
+            },
+        });
+    });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { title };
+//# sourceMappingURL=signality-core-router-title.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"signality-core-router-title.mjs","sources":["../../../projects/core/router/title/index.ts","../../../projects/core/router/title/signality-core-router-title.ts"],"sourcesContent":["import { type CreateSignalOptions, inject, linkedSignal, type WritableSignal } from '@angular/core';\nimport { ActivatedRoute } from '@angular/router';\nimport { Title } from '@angular/platform-browser';\nimport { toSignal } from '@angular/core/rxjs-interop';\nimport { filter } from 'rxjs';\nimport { proxySignal, setupContext } from '@signality/core/internal';\nimport type { WithInjector } from '@signality/core/types';\n\nexport type TitleOptions = CreateSignalOptions<string> & WithInjector;\n\n/**\n * Reactive wrapper around the [Angular Router](https://angular.dev/guide/routing) route title.\n *\n * @param options - Optional configuration\n * @returns A writable signal containing the current route title (string)\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     <div>\n *       <h1>{{ pageTitle() }}</h1>\n *       <button (click)=\"updateTitle()\">Update Title</button>\n *     </div>\n *   `\n * })\n * class PageComponent {\n *   readonly pageTitle = title();\n *\n *   updateTitle() {\n *     this.pageTitle.set('New Page Title');\n *   }\n * }\n * ```\n */\nexport function title(options?: TitleOptions): WritableSignal<string> {\n  const { runInContext } = setupContext(options?.injector, title);\n\n  return runInContext(() => {\n    const route = inject(ActivatedRoute);\n    const html = inject(Title);\n\n    return proxySignal(\n      linkedSignal(\n        toSignal<string, string>(route.title.pipe(filter(Boolean)), {\n          initialValue: route.snapshot.title || html.getTitle(),\n        }),\n        { ...options }\n      ),\n      {\n        set: (value, source) => {\n          html.setTitle(value);\n          source.set(value);\n        },\n      }\n    );\n  });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;;;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACG,SAAU,KAAK,CAAC,OAAsB,EAAA;AAC1C,IAAA,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,KAAK,CAAC;IAE/D,OAAO,YAAY,CAAC,MAAK;AACvB,QAAA,MAAM,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC;AACpC,QAAA,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC;AAE1B,QAAA,OAAO,WAAW,CAChB,YAAY,CACV,QAAQ,CAAiB,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE;YAC1D,YAAY,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,IAAI,IAAI,CAAC,QAAQ,EAAE;AACtD,SAAA,CAAC,EACF,EAAE,GAAG,OAAO,EAAE,CACf,EACD;AACE,YAAA,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,KAAI;AACrB,gBAAA,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;AACpB,gBAAA,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC;YACnB,CAAC;AACF,SAAA,CACF;AACH,IAAA,CAAC,CAAC;AACJ;;ACzDA;;AAEG;;;;"}

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

@@ -0,0 +1,53 @@
+import { inject, signal } from '@angular/core';
+import { Router } from '@angular/router';
+import { setupContext, constSignal } from '@signality/core/internal';
+import { routerListener } from '@signality/core/router/router-listener';
+
+/**
+ * Reactive wrapper around the [Angular Router](https://angular.dev/guide/routing) current URL.
+ *
+ * @param options - Optional configuration
+ * @returns A signal containing the current URL
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     <div>
+ *       <p>Current URL: {{ currentUrl() }}</p>
+ *       <p>Absolute URL: {{ absoluteUrl() }}</p>
+ *     </div>
+ *   `
+ * })
+ * class UrlComponent {
+ *   readonly currentUrl = url();
+ *   readonly absoluteUrl = url({ absolute: true });
+ * }
+ * ```
+ */
+function url(options) {
+    const { runInContext } = setupContext(options?.injector, url);
+    return runInContext(({ isServer }) => {
+        const router = inject(Router);
+        if (isServer) {
+            return constSignal(router.url);
+        }
+        const getUrl = () => {
+            const relativeUrl = router.url;
+            if (options?.absolute) {
+                return location.origin + relativeUrl;
+            }
+            return relativeUrl;
+        };
+        const result = signal(getUrl(), options);
+        routerListener('navigationend', () => result.set(getUrl()));
+        return result.asReadonly();
+    });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { url };
+//# sourceMappingURL=signality-core-router-url.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"signality-core-router-url.mjs","sources":["../../../projects/core/router/url/index.ts","../../../projects/core/router/url/signality-core-router-url.ts"],"sourcesContent":["import { type CreateSignalOptions, inject, signal, type Signal } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { constSignal, setupContext } from '@signality/core/internal';\nimport type { WithInjector } from '@signality/core/types';\nimport { routerListener } from '@signality/core/router/router-listener';\n\nexport interface UrlOptions extends CreateSignalOptions<string>, WithInjector {\n  /**\n   * Include origin (protocol + host) for absolute URL.\n   * @default false\n   */\n  readonly absolute?: boolean;\n}\n\n/**\n * Reactive wrapper around the [Angular Router](https://angular.dev/guide/routing) current URL.\n *\n * @param options - Optional configuration\n * @returns A signal containing the current URL\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     <div>\n *       <p>Current URL: {{ currentUrl() }}</p>\n *       <p>Absolute URL: {{ absoluteUrl() }}</p>\n *     </div>\n *   `\n * })\n * class UrlComponent {\n *   readonly currentUrl = url();\n *   readonly absoluteUrl = url({ absolute: true });\n * }\n * ```\n */\nexport function url(options?: UrlOptions): Signal<string> {\n  const { runInContext } = setupContext(options?.injector, url);\n\n  return runInContext(({ isServer }) => {\n    const router = inject(Router);\n\n    if (isServer) {\n      return constSignal(router.url);\n    }\n\n    const getUrl = () => {\n      const relativeUrl = router.url;\n\n      if (options?.absolute) {\n        return location.origin + relativeUrl;\n      }\n\n      return relativeUrl;\n    };\n\n    const result = signal(getUrl(), options);\n\n    routerListener('navigationend', () => result.set(getUrl()));\n\n    return result.asReadonly();\n  });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;;;AAcA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACG,SAAU,GAAG,CAAC,OAAoB,EAAA;AACtC,IAAA,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,CAAC;AAE7D,IAAA,OAAO,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAI;AACnC,QAAA,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAE7B,IAAI,QAAQ,EAAE;AACZ,YAAA,OAAO,WAAW,CAAC,MAAM,CAAC,GAAG,CAAC;QAChC;QAEA,MAAM,MAAM,GAAG,MAAK;AAClB,YAAA,MAAM,WAAW,GAAG,MAAM,CAAC,GAAG;AAE9B,YAAA,IAAI,OAAO,EAAE,QAAQ,EAAE;AACrB,gBAAA,OAAO,QAAQ,CAAC,MAAM,GAAG,WAAW;YACtC;AAEA,YAAA,OAAO,WAAW;AACpB,QAAA,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,OAAO,CAAC;AAExC,QAAA,cAAc,CAAC,eAAe,EAAE,MAAM,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC;AAE3D,QAAA,OAAO,MAAM,CAAC,UAAU,EAAE;AAC5B,IAAA,CAAC,CAAC;AACJ;;AC9DA;;AAEG;;;;"}

package/fesm2022/signality-core-router.mjs

@@ -0,0 +1,12 @@
+export * from '@signality/core/router/params';
+export * from '@signality/core/router/query-params';
+export * from '@signality/core/router/fragment';
+export * from '@signality/core/router/title';
+export * from '@signality/core/router/url';
+export * from '@signality/core/router/route-data';
+export * from '@signality/core/router/router-listener';
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+//# sourceMappingURL=signality-core-router.mjs.map

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

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

package/fesm2022/signality-core-scheduling-debounce-callback.mjs

@@ -0,0 +1,59 @@
+import { setupContext, toValue } from '@signality/core/internal';
+
+/**
+ * Creates a debounced version of a callback function.
+ * The callback will only be executed after the specified wait time has elapsed since the last invocation.
+ *
+ * @param callback - The function to debounce
+ * @param wait - Debounce delay in milliseconds (can be a reactive signal)
+ * @param options - Optional configuration including injector
+ * @returns A debounced version of the callback function
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     <input (input)="handleInput($event.target.value)" />
+ *   `,
+ * })
+ * export class SearchComponent {
+ *   readonly debounceTime = input(300);
+ *   readonly searchChange = output<string>();
+ *
+ *   readonly handleInput = debounceCallback(value => {
+ *     this.searchChange.emit(value);
+ *   }, this.debounceTime);
+ * }
+ * ```
+ */
+function debounceCallback(callback, wait, options) {
+    const { runInContext } = setupContext(options?.injector, debounceCallback);
+    return runInContext(({ isServer, onCleanup }) => {
+        if (isServer) {
+            return callback;
+        }
+        let timer;
+        onCleanup(() => {
+            if (timer !== undefined) {
+                clearTimeout(timer);
+            }
+        });
+        return new Proxy(callback, {
+            apply(target, thisArg, args) {
+                if (timer !== undefined) {
+                    clearTimeout(timer);
+                }
+                timer = setTimeout(() => {
+                    target.apply(thisArg, args);
+                }, toValue.untracked(wait));
+            },
+        });
+    });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { debounceCallback };
+//# sourceMappingURL=signality-core-scheduling-debounce-callback.mjs.map

package/fesm2022/signality-core-scheduling-debounce-callback.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signality-core-scheduling-debounce-callback.mjs","sources":["../../../projects/core/scheduling/debounce-callback/index.ts","../../../projects/core/scheduling/debounce-callback/signality-core-scheduling-debounce-callback.ts"],"sourcesContent":["import type { MaybeSignal, WithInjector } from '@signality/core/types';\nimport { setupContext, type Timer, toValue } from '@signality/core/internal';\n\n/**\n * Creates a debounced version of a callback function.\n * The callback will only be executed after the specified wait time has elapsed since the last invocation.\n *\n * @param callback - The function to debounce\n * @param wait - Debounce delay in milliseconds (can be a reactive signal)\n * @param options - Optional configuration including injector\n * @returns A debounced version of the callback function\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     <input (input)=\"handleInput($event.target.value)\" />\n *   `,\n * })\n * export class SearchComponent {\n *   readonly debounceTime = input(300);\n *   readonly searchChange = output<string>();\n *\n *   readonly handleInput = debounceCallback(value => {\n *     this.searchChange.emit(value);\n *   }, this.debounceTime);\n * }\n * ```\n */\nexport function debounceCallback<T extends (...args: any[]) => any>(\n  callback: T,\n  wait: MaybeSignal<number>,\n  options?: WithInjector\n): T {\n  const { runInContext } = setupContext(options?.injector, debounceCallback);\n\n  return runInContext(({ isServer, onCleanup }) => {\n    if (isServer) {\n      return callback;\n    }\n\n    let timer: Timer;\n\n    onCleanup(() => {\n      if (timer !== undefined) {\n        clearTimeout(timer);\n      }\n    });\n\n    return new Proxy(callback, {\n      apply(target, thisArg, args) {\n        if (timer !== undefined) {\n          clearTimeout(timer);\n        }\n        timer = setTimeout(() => {\n          target.apply(thisArg, args);\n        }, toValue.untracked(wait));\n      },\n    });\n  });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;SACa,gBAAgB,CAC9B,QAAW,EACX,IAAyB,EACzB,OAAsB,EAAA;AAEtB,IAAA,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,gBAAgB,CAAC;IAE1E,OAAO,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAI;QAC9C,IAAI,QAAQ,EAAE;AACZ,YAAA,OAAO,QAAQ;QACjB;AAEA,QAAA,IAAI,KAAY;QAEhB,SAAS,CAAC,MAAK;AACb,YAAA,IAAI,KAAK,KAAK,SAAS,EAAE;gBACvB,YAAY,CAAC,KAAK,CAAC;YACrB;AACF,QAAA,CAAC,CAAC;AAEF,QAAA,OAAO,IAAI,KAAK,CAAC,QAAQ,EAAE;AACzB,YAAA,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAA;AACzB,gBAAA,IAAI,KAAK,KAAK,SAAS,EAAE;oBACvB,YAAY,CAAC,KAAK,CAAC;gBACrB;AACA,gBAAA,KAAK,GAAG,UAAU,CAAC,MAAK;AACtB,oBAAA,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC;gBAC7B,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YAC7B,CAAC;AACF,SAAA,CAAC;AACJ,IAAA,CAAC,CAAC;AACJ;;AC5DA;;AAEG;;;;"}

package/fesm2022/signality-core-scheduling-interval.mjs

@@ -0,0 +1,110 @@
+import { signal, untracked, isSignal } from '@angular/core';
+import { setupContext, NOOP_FN, constSignal, toValue } from '@signality/core/internal';
+import { watcher } from '@signality/core/reactivity/watcher';
+
+/**
+ * Creates a reactive interval that executes a callback function at specified intervals.
+ * Automatically handles cleanup and supports reactive interval duration.
+ *
+ * @param callback - Function to execute on each interval tick, receives current counter value
+ * @param intervalMs - Interval duration in milliseconds (can be a reactive signal)
+ * @param options - Optional configuration including immediate start and injector
+ * @returns An IntervalRef with control methods and state signals
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     <p>Status: {{ polling.isActive() ? 'Polling' : 'Stopped' }}</p>
+ *     <button (click)="polling.pause()">Stop</button>
+ *     <button (click)="polling.resume()">Start</button>
+ *   `,
+ * })
+ * export class PeriodicTask {
+ *   readonly polling = interval(async () => {
+ *     await this.checkStatus();
+ *   }, 5000);
+ *
+ *   async checkStatus() {
+ *     // async operation
+ *   }
+ * }
+ * ```
+ */
+function interval(callback, intervalMs, options) {
+    const { runInContext } = setupContext(options?.injector, interval);
+    return runInContext(({ isServer, onCleanup }) => {
+        if (isServer) {
+            return {
+                isActive: constSignal(false),
+                counter: constSignal(0),
+                pause: NOOP_FN,
+                resume: NOOP_FN,
+                reset: NOOP_FN,
+            };
+        }
+        const isActive = signal(false, ...(ngDevMode ? [{ debugName: "isActive" }] : []));
+        const counter = signal(0, ...(ngDevMode ? [{ debugName: "counter" }] : []));
+        let intervalId;
+        const start = () => {
+            untracked(() => {
+                if (intervalId !== undefined || !isActive()) {
+                    return;
+                }
+                const ms = toValue(intervalMs);
+                intervalId = setInterval(() => {
+                    const currentCounter = counter() + 1;
+                    counter.set(currentCounter);
+                    callback(currentCounter);
+                }, ms);
+            });
+        };
+        const pause = () => {
+            cleanup();
+            isActive.set(false);
+        };
+        const cleanup = () => {
+            if (intervalId !== undefined) {
+                clearInterval(intervalId);
+                intervalId = undefined;
+            }
+        };
+        const resume = () => {
+            if (intervalId !== undefined) {
+                return;
+            }
+            isActive.set(true);
+            start();
+        };
+        const reset = () => {
+            counter.set(0);
+        };
+        if (isSignal(intervalMs)) {
+            watcher(intervalMs, newMs => {
+                if (isActive() && newMs !== undefined) {
+                    cleanup();
+                    start();
+                }
+            });
+        }
+        onCleanup(cleanup);
+        if (options?.immediate) {
+            isActive.set(true);
+            start();
+        }
+        return {
+            isActive: isActive.asReadonly(),
+            counter: counter.asReadonly(),
+            pause,
+            resume,
+            reset,
+        };
+    });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { interval };
+//# sourceMappingURL=signality-core-scheduling-interval.mjs.map

package/fesm2022/signality-core-scheduling-interval.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signality-core-scheduling-interval.mjs","sources":["../../../projects/core/scheduling/interval/index.ts","../../../projects/core/scheduling/interval/signality-core-scheduling-interval.ts"],"sourcesContent":["import { isSignal, signal, type Signal, untracked } from '@angular/core';\nimport { constSignal, NOOP_FN, setupContext, type Timer, toValue } from '@signality/core/internal';\nimport type { MaybeSignal, WithInjector } from '@signality/core/types';\nimport { watcher } from '@signality/core/reactivity/watcher';\n\nexport interface IntervalOptions extends WithInjector {\n  /**\n   * Whether to start the interval immediately.\n   * @default false\n   */\n  readonly immediate?: boolean;\n}\n\nexport interface IntervalRef {\n  /** Whether the interval is currently active */\n  readonly isActive: Signal<boolean>;\n\n  /** Number of times the callback has been executed */\n  readonly counter: Signal<number>;\n\n  /** Pause the interval */\n  readonly pause: () => void;\n\n  /** Resume the interval */\n  readonly resume: () => void;\n\n  /** Reset the counter to 0 */\n  readonly reset: () => void;\n}\n\n/**\n * Creates a reactive interval that executes a callback function at specified intervals.\n * Automatically handles cleanup and supports reactive interval duration.\n *\n * @param callback - Function to execute on each interval tick, receives current counter value\n * @param intervalMs - Interval duration in milliseconds (can be a reactive signal)\n * @param options - Optional configuration including immediate start and injector\n * @returns An IntervalRef with control methods and state signals\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     <p>Status: {{ polling.isActive() ? 'Polling' : 'Stopped' }}</p>\n *     <button (click)=\"polling.pause()\">Stop</button>\n *     <button (click)=\"polling.resume()\">Start</button>\n *   `,\n * })\n * export class PeriodicTask {\n *   readonly polling = interval(async () => {\n *     await this.checkStatus();\n *   }, 5000);\n *\n *   async checkStatus() {\n *     // async operation\n *   }\n * }\n * ```\n */\nexport function interval(\n  callback: (counter: number) => void,\n  intervalMs: MaybeSignal<number>,\n  options?: IntervalOptions\n): IntervalRef {\n  const { runInContext } = setupContext(options?.injector, interval);\n\n  return runInContext(({ isServer, onCleanup }) => {\n    if (isServer) {\n      return {\n        isActive: constSignal(false),\n        counter: constSignal(0),\n        pause: NOOP_FN,\n        resume: NOOP_FN,\n        reset: NOOP_FN,\n      };\n    }\n\n    const isActive = signal(false);\n    const counter = signal(0);\n\n    let intervalId: Timer;\n\n    const start = () => {\n      untracked(() => {\n        if (intervalId !== undefined || !isActive()) {\n          return;\n        }\n\n        const ms = toValue(intervalMs);\n\n        intervalId = setInterval(() => {\n          const currentCounter = counter() + 1;\n          counter.set(currentCounter);\n          callback(currentCounter);\n        }, ms);\n      });\n    };\n\n    const pause = () => {\n      cleanup();\n      isActive.set(false);\n    };\n\n    const cleanup = () => {\n      if (intervalId !== undefined) {\n        clearInterval(intervalId);\n        intervalId = undefined;\n      }\n    };\n\n    const resume = () => {\n      if (intervalId !== undefined) {\n        return;\n      }\n\n      isActive.set(true);\n      start();\n    };\n\n    const reset = () => {\n      counter.set(0);\n    };\n\n    if (isSignal(intervalMs)) {\n      watcher(intervalMs, newMs => {\n        if (isActive() && newMs !== undefined) {\n          cleanup();\n          start();\n        }\n      });\n    }\n\n    onCleanup(cleanup);\n\n    if (options?.immediate) {\n      isActive.set(true);\n      start();\n    }\n\n    return {\n      isActive: isActive.asReadonly(),\n      counter: counter.asReadonly(),\n      pause,\n      resume,\n      reset,\n    };\n  });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;;AA8BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;SACa,QAAQ,CACtB,QAAmC,EACnC,UAA+B,EAC/B,OAAyB,EAAA;AAEzB,IAAA,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC;IAElE,OAAO,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAI;QAC9C,IAAI,QAAQ,EAAE;YACZ,OAAO;AACL,gBAAA,QAAQ,EAAE,WAAW,CAAC,KAAK,CAAC;AAC5B,gBAAA,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC;AACvB,gBAAA,KAAK,EAAE,OAAO;AACd,gBAAA,MAAM,EAAE,OAAO;AACf,gBAAA,KAAK,EAAE,OAAO;aACf;QACH;AAEA,QAAA,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,oDAAC;AAC9B,QAAA,MAAM,OAAO,GAAG,MAAM,CAAC,CAAC,mDAAC;AAEzB,QAAA,IAAI,UAAiB;QAErB,MAAM,KAAK,GAAG,MAAK;YACjB,SAAS,CAAC,MAAK;gBACb,IAAI,UAAU,KAAK,SAAS,IAAI,CAAC,QAAQ,EAAE,EAAE;oBAC3C;gBACF;AAEA,gBAAA,MAAM,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC;AAE9B,gBAAA,UAAU,GAAG,WAAW,CAAC,MAAK;AAC5B,oBAAA,MAAM,cAAc,GAAG,OAAO,EAAE,GAAG,CAAC;AACpC,oBAAA,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC;oBAC3B,QAAQ,CAAC,cAAc,CAAC;gBAC1B,CAAC,EAAE,EAAE,CAAC;AACR,YAAA,CAAC,CAAC;AACJ,QAAA,CAAC;QAED,MAAM,KAAK,GAAG,MAAK;AACjB,YAAA,OAAO,EAAE;AACT,YAAA,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC;AACrB,QAAA,CAAC;QAED,MAAM,OAAO,GAAG,MAAK;AACnB,YAAA,IAAI,UAAU,KAAK,SAAS,EAAE;gBAC5B,aAAa,CAAC,UAAU,CAAC;gBACzB,UAAU,GAAG,SAAS;YACxB;AACF,QAAA,CAAC;QAED,MAAM,MAAM,GAAG,MAAK;AAClB,YAAA,IAAI,UAAU,KAAK,SAAS,EAAE;gBAC5B;YACF;AAEA,YAAA,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC;AAClB,YAAA,KAAK,EAAE;AACT,QAAA,CAAC;QAED,MAAM,KAAK,GAAG,MAAK;AACjB,YAAA,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;AAChB,QAAA,CAAC;AAED,QAAA,IAAI,QAAQ,CAAC,UAAU,CAAC,EAAE;AACxB,YAAA,OAAO,CAAC,UAAU,EAAE,KAAK,IAAG;AAC1B,gBAAA,IAAI,QAAQ,EAAE,IAAI,KAAK,KAAK,SAAS,EAAE;AACrC,oBAAA,OAAO,EAAE;AACT,oBAAA,KAAK,EAAE;gBACT;AACF,YAAA,CAAC,CAAC;QACJ;QAEA,SAAS,CAAC,OAAO,CAAC;AAElB,QAAA,IAAI,OAAO,EAAE,SAAS,EAAE;AACtB,YAAA,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC;AAClB,YAAA,KAAK,EAAE;QACT;QAEA,OAAO;AACL,YAAA,QAAQ,EAAE,QAAQ,CAAC,UAAU,EAAE;AAC/B,YAAA,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE;YAC7B,KAAK;YACL,MAAM;YACN,KAAK;SACN;AACH,IAAA,CAAC,CAAC;AACJ;;ACnJA;;AAEG;;;;"}

package/fesm2022/signality-core-scheduling-throttle-callback.mjs

@@ -0,0 +1,66 @@
+import { setupContext, toValue } from '@signality/core/internal';
+
+/**
+ * Creates a throttled version of a callback function.
+ * The callback will be executed at most once per specified wait interval.
+ *
+ * @param callback - The function to throttle
+ * @param wait - Throttle interval in milliseconds (can be a reactive signal)
+ * @param options - Optional configuration including injector
+ * @returns A throttled version of the callback function
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     <div (scroll)="handleScroll($event)">
+ *       Scrollable content
+ *     </div>
+ *   `,
+ * })
+ * export class ScrollComponent {
+ *   readonly throttleTime = input(300);
+ *   readonly scrollChange = output<Event>();
+ *
+ *   readonly handleScroll = throttleCallback(e => {
+ *     this.scrollChange.emit(e);
+ *   }, this.throttleTime);
+ * }
+ * ```
+ */
+function throttleCallback(callback, wait, options) {
+    const { runInContext } = setupContext(options?.injector, throttleCallback);
+    return runInContext(({ isServer, onCleanup }) => {
+        if (isServer) {
+            return callback;
+        }
+        let timer;
+        let isThrottled;
+        let lastArgs;
+        onCleanup(() => {
+            if (timer !== undefined) {
+                clearTimeout(timer);
+            }
+        });
+        return new Proxy(callback, {
+            apply(target, thisArg, args) {
+                lastArgs = args;
+                if (isThrottled) {
+                    return;
+                }
+                target.apply(thisArg, lastArgs);
+                isThrottled = true;
+                timer = setTimeout(() => {
+                    isThrottled = false;
+                }, toValue.untracked(wait));
+            },
+        });
+    });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { throttleCallback };
+//# sourceMappingURL=signality-core-scheduling-throttle-callback.mjs.map

package/fesm2022/signality-core-scheduling-throttle-callback.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signality-core-scheduling-throttle-callback.mjs","sources":["../../../projects/core/scheduling/throttle-callback/index.ts","../../../projects/core/scheduling/throttle-callback/signality-core-scheduling-throttle-callback.ts"],"sourcesContent":["import type { MaybeSignal, WithInjector } from '@signality/core/types';\nimport { setupContext, type Timer, toValue } from '@signality/core/internal';\n\n/**\n * Creates a throttled version of a callback function.\n * The callback will be executed at most once per specified wait interval.\n *\n * @param callback - The function to throttle\n * @param wait - Throttle interval in milliseconds (can be a reactive signal)\n * @param options - Optional configuration including injector\n * @returns A throttled version of the callback function\n *\n * @example\n * ```typescript\n * @Component({\n *   template: `\n *     <div (scroll)=\"handleScroll($event)\">\n *       Scrollable content\n *     </div>\n *   `,\n * })\n * export class ScrollComponent {\n *   readonly throttleTime = input(300);\n *   readonly scrollChange = output<Event>();\n *\n *   readonly handleScroll = throttleCallback(e => {\n *     this.scrollChange.emit(e);\n *   }, this.throttleTime);\n * }\n * ```\n */\nexport function throttleCallback<T extends (...args: any[]) => any>(\n  callback: T,\n  wait: MaybeSignal<number>,\n  options?: WithInjector\n): T {\n  const { runInContext } = setupContext(options?.injector, throttleCallback);\n\n  return runInContext(({ isServer, onCleanup }) => {\n    if (isServer) {\n      return callback;\n    }\n\n    let timer: Timer;\n    let isThrottled: boolean;\n    let lastArgs: Parameters<T>;\n\n    onCleanup(() => {\n      if (timer !== undefined) {\n        clearTimeout(timer);\n      }\n    });\n\n    return new Proxy(callback, {\n      apply(target, thisArg, args) {\n        lastArgs = args as Parameters<T>;\n\n        if (isThrottled) {\n          return;\n        }\n\n        target.apply(thisArg, lastArgs);\n        isThrottled = true;\n\n        timer = setTimeout(() => {\n          isThrottled = false;\n        }, toValue.untracked(wait));\n      },\n    });\n  });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;SACa,gBAAgB,CAC9B,QAAW,EACX,IAAyB,EACzB,OAAsB,EAAA;AAEtB,IAAA,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,gBAAgB,CAAC;IAE1E,OAAO,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAI;QAC9C,IAAI,QAAQ,EAAE;AACZ,YAAA,OAAO,QAAQ;QACjB;AAEA,QAAA,IAAI,KAAY;AAChB,QAAA,IAAI,WAAoB;AACxB,QAAA,IAAI,QAAuB;QAE3B,SAAS,CAAC,MAAK;AACb,YAAA,IAAI,KAAK,KAAK,SAAS,EAAE;gBACvB,YAAY,CAAC,KAAK,CAAC;YACrB;AACF,QAAA,CAAC,CAAC;AAEF,QAAA,OAAO,IAAI,KAAK,CAAC,QAAQ,EAAE;AACzB,YAAA,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAA;gBACzB,QAAQ,GAAG,IAAqB;gBAEhC,IAAI,WAAW,EAAE;oBACf;gBACF;AAEA,gBAAA,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC;gBAC/B,WAAW,GAAG,IAAI;AAElB,gBAAA,KAAK,GAAG,UAAU,CAAC,MAAK;oBACtB,WAAW,GAAG,KAAK;gBACrB,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YAC7B,CAAC;AACF,SAAA,CAAC;AACJ,IAAA,CAAC,CAAC;AACJ;;ACtEA;;AAEG;;;;"}

package/fesm2022/signality-core-scheduling.mjs

@@ -0,0 +1,8 @@
+export * from '@signality/core/scheduling/debounce-callback';
+export * from '@signality/core/scheduling/interval';
+export * from '@signality/core/scheduling/throttle-callback';
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+//# sourceMappingURL=signality-core-scheduling.mjs.map

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

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

package/fesm2022/signality-core-types.mjs

@@ -0,0 +1,4 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+//# sourceMappingURL=signality-core-types.mjs.map

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

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

package/fesm2022/signality-core.mjs

@@ -0,0 +1,13 @@
+export * from '@signality/core/reactivity';
+export * from '@signality/core/scheduling';
+export * from '@signality/core/observers';
+export * from '@signality/core/browser';
+export * from '@signality/core/elements';
+export * from '@signality/core/router';
+export * from '@signality/core/forms';
+export * from '@signality/core/types';
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+//# sourceMappingURL=signality-core.mjs.map

package/fesm2022/signality-core.mjs.map

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

package/forms/cva/index.d.ts

@@ -0,0 +1,60 @@
+import { type Signal, type WritableSignal } from '@angular/core';
+import { type ValidationErrors } from '@angular/forms';
+import type { WithInjector } from '@signality/core/types';
+export type CvaOptions<T> = Omit<Partial<MakeWritable<CvaRef<T>>>, 'value'> & Pick<CvaRef<T>, 'value'> & WithInjector;
+export interface CvaRef<T> {
+    readonly value: WritableSignal<T>;
+    readonly touched: WritableSignal<boolean>;
+    readonly disabled: Signal<boolean>;
+    readonly required: Signal<boolean>;
+    readonly invalid: Signal<boolean>;
+    readonly pending: Signal<boolean>;
+    readonly dirty: Signal<boolean>;
+    readonly errors: Signal<ValidationErrors | null>;
+    readonly reset: () => void;
+}
+/**
+ * Reactive wrapper around the [Angular Forms](https://angular.dev/guide/forms) Control Value Accessor (CVA) pattern.
+ * Integrates seamlessly with both template-driven and reactive forms.
+ *
+ * @param options - Configuration options including the value signal
+ * @returns A CvaRef with reactive form control state signals
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   selector: 'app-currency-input',
+ *   template: `
+ *     <input
+ *       type="text"
+ *       [value]="displayValue()"
+ *       [required]="cva.required()"
+ *       (input)="handleInput($any($event.target).value)"
+ *       (blur)="cva.touched.set(true)"
+ *     />
+ *   `,
+ * })
+ * export class CurrencyInput {
+ *   readonly value = model(0);
+ *   readonly cva = cva({ value: this.value });
+ *
+ *   readonly displayValue = computed(() => {
+ *     return this.value()
+ *       .toFixed(2)
+ *       .replace(/\B(?=(\d{3})+(?!\d))/g, ','); // Shows "1,234.56"
+ *   });
+ *
+ *   handleInput(input: string) {
+ *     const num = parseFloat(input.replace(/[^0-9.]/g, ''));
+ *     if (!isNaN(num)) {
+ *       this.value.set(num);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare function cva<T>(options: CvaOptions<T>): CvaRef<T>;
+type MakeWritable<T extends object> = {
+    [K in keyof T]: T[K] extends Signal<infer U> ? WritableSignal<U> : never;
+};
+export {};

package/forms/index.d.ts

@@ -0,0 +1 @@
+export * from '@signality/core/forms/cva';

package/index.d.ts

@@ -0,0 +1,8 @@
+export * from '@signality/core/reactivity';
+export * from '@signality/core/scheduling';
+export * from '@signality/core/observers';
+export * from '@signality/core/browser';
+export * from '@signality/core/elements';
+export * from '@signality/core/router';
+export * from '@signality/core/forms';
+export * from '@signality/core/types';

package/internal/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from './mobile-regex';
+export * from './stubs';

package/internal/constants/mobile-regex.d.ts

@@ -0,0 +1 @@
+export declare const MOBILE_REGEX: RegExp;

package/internal/constants/stubs.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Empty synchronous function stub.
+ * Used for SSR compatibility when returning method functions in Ref objects that should do nothing on the server.
+ *
+ * Example: `close: NOOP_FN` in {@link WebNotificationRef}
+ */
+export declare const NOOP_FN: (...args: any[]) => void;
+/**
+ * Empty asynchronous function stub that returns a resolved Promise.
+ * Used for SSR compatibility when returning async method functions in Ref objects that should do nothing on the server.
+ *
+ * Example: `share: NOOP_ASYNC_FN` in {@link WebShareRef}
+ */
+export declare const NOOP_ASYNC_FN: () => Promise<void>;
+/**
+ * Frozen EffectRef stub with a no-op destroy method.
+ * Used for SSR compatibility when returning EffectRef from observer utilities (ResizeObserver, MutationObserver, etc.)
+ * that cannot run on the server. Prevents errors when calling destroy() on server-rendered refs.
+ *
+ * Example: `return NOOP_EFFECT_REF` in {@link resizeObserver}
+ */
+export declare const NOOP_EFFECT_REF: {
+    destroy: (...args: any[]) => void;
+};
+/**
+ * Equality function that always returns false, forcing signal updates on every change.
+ * Used for signals that hold mutable objects (like Selection, Range) where reference equality is not sufficient
+ * and we need to detect changes even when the object structure appears the same.
+ *
+ * Example: `signal<Selection | null>(null, { equal: ALWAYS_FALSE_FN })` in {@link textSelection}
+ */
+export declare const ALWAYS_FALSE_FN: () => boolean;

package/internal/index.d.ts

@@ -0,0 +1,4 @@
+export * from './constants';
+export * from './providers';
+export * from './types';
+export * from './utils';