@signap/signals-angular 2.0.0

package/LICENSE

@@ -0,0 +1,143 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work; and
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or agreed
+      to in writing, Licensor provides the Work on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+   8. Limitation of Liability. In no event and under no legal theory shall
+      any Contributor be liable to You for damages, including any direct,
+      indirect, special, incidental, or consequential damages of any
+      character arising as a result of this License or out of the use or
+      inability to use the Work.
+
+   9. Accepting Warranty or Additional Liability. While redistributing the
+      Work or Derivative Works thereof, You may choose to offer, and charge
+      a fee for, acceptance of support, warranty, indemnity, or other
+      liability obligations and/or rights consistent with this License.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Signap Technology
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,100 @@
+# @signap/signals-angular
+
+Angular (standalone) wrapper for `@signap/signals-web` — a `provideSignals()`
+provider plus an `injectVisitorData()` helper that mirror the React hook and Vue
+composable.
+
+## Install
+
+```bash
+pnpm add @signap/signals-angular
+# @angular/core and @angular/common are peerDependencies (>=17 <21)
+```
+
+## Usage
+
+Register the agent once with `provideSignals()` at bootstrap, then call
+`injectVisitorData()` in any component below it.
+
+### Provider (app bootstrap)
+
+```ts
+// main.ts
+import { bootstrapApplication } from "@angular/platform-browser";
+import { provideSignals } from "@signap/signals-angular";
+import { AppComponent } from "./app.component";
+
+bootstrapApplication(AppComponent, {
+  providers: [
+    provideSignals({
+      apiKey: "pk_live_...",
+      endpoint: "https://ingest.signap.example",
+    }),
+  ],
+});
+```
+
+### Consume (`injectVisitorData`)
+
+```ts
+// visitor-badge.component.ts
+import { Component } from "@angular/core";
+import { injectVisitorData } from "@signap/signals-angular";
+
+@Component({
+  selector: "visitor-badge",
+  standalone: true,
+  template: `
+    @if (visitor.isLoading()) {
+      <p>Identifying…</p>
+    } @else if (visitor.error()) {
+      <p>Failed: {{ visitor.error()?.message }}</p>
+    } @else {
+      <p>visitor: {{ visitor.data()?.visitorId }}</p>
+      <p>confidence: {{ visitor.data()?.confidence }}</p>
+      <button (click)="visitor.refetch()">Re-identify</button>
+    }
+  `,
+})
+export class VisitorBadgeComponent {
+  // Field initializers run in the injection context, so injectVisitorData() is valid here.
+  readonly visitor = injectVisitorData({ tag: "page-view" });
+}
+```
+
+## Helper shape (v2)
+
+`injectVisitorData()` runs `agent.identify()` once when the agent is ready and
+exposes the resolved visitor as Angular **signals**. ADR §A2 means one
+round-trip — no separate ack/lookup transition.
+
+| field       | type                                     | when populated                         |
+|-------------|------------------------------------------|----------------------------------------|
+| `data`      | `Signal<IdentifyResult \| undefined>`    | once `agent.identify()` resolves       |
+| `isLoading` | `Signal<boolean>`                        | true between call time and `data`       |
+| `error`     | `Signal<Error \| null>`                  | last failure (load / identify)         |
+| `refetch`   | `() => Promise<void>`                    | re-run `agent.identify()`              |
+
+Read each signal by calling it (`visitor.data()`), in a template or a
+`computed`/`effect`.
+
+SSR-safe: `provideSignals()` gates `SignalsAgent.load()` behind
+`isPlatformBrowser(PLATFORM_ID)`, so it never runs during Angular Universal /
+prerender server rendering.
+
+## Endpoint (required)
+
+`provideSignals()` takes the underlying `AgentLoadOptions`. `endpoint` is
+**required** — the published SDK ships no baked default host (the region→host map
+is empty in this alpha), so pass an explicit `endpoint` (a string or a callback).
+See the `@signap/signals-web` README (Endpoint section).
+
+> `opts` is snapshotted at bootstrap (later changes are ignored — re-bootstrap to
+> swap apiKey/endpoint), the same contract as the React/Vue wrappers.
+
+## Why decorator-free
+
+The package ships a functional provider, an `inject()` helper, and a plain class
+wired through a DI factory — no `@Injectable`/`@Component` decorators. That keeps
+it AOT-safe under a plain `tsup` build (no ng-packagr / partial-Ivy step needed)
+and importable from any Angular 17+ app.

package/dist/index.cjs

@@ -0,0 +1,143 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SIGNALS_CLIENT: () => SIGNALS_CLIENT,
+  SdkError: () => import_signals_web2.SdkError,
+  SignalsClient: () => SignalsClient,
+  WEB_SDK_VERSION: () => import_signals_web2.VERSION,
+  injectVisitorData: () => injectVisitorData,
+  provideSignals: () => provideSignals
+});
+module.exports = __toCommonJS(index_exports);
+var import_signals_web2 = require("@signap/signals-web");
+
+// src/client.ts
+var import_core = require("@angular/core");
+var import_signals_web = require("@signap/signals-web");
+var SignalsClient = class {
+  agentState = (0, import_core.signal)(null);
+  loadErrorState = (0, import_core.signal)(null);
+  /** Resolved agent, or `null` until `SignalsAgent.load()` settles. */
+  agent = this.agentState.asReadonly();
+  /** Non-null if `SignalsAgent.load()` rejected. */
+  loadError = this.loadErrorState.asReadonly();
+  /**
+   * Resolves once `load()` has settled (agent set OR loadError set). Lets
+   * `injectVisitorData()` await readiness without an Angular `effect`, so the
+   * auto-identify fires exactly once regardless of change-detection timing.
+   */
+  ready;
+  /**
+   * @param opts    forwarded verbatim to `SignalsAgent.load()`.
+   * @param browser whether we're running in a browser; `load()` only fires
+   *                client-side so SSR / prerender never touches
+   *                window/document/WebCrypto (the Angular analog of the Vue
+   *                plugin's `typeof window` guard).
+   */
+  constructor(opts, browser) {
+    if (!browser) {
+      this.ready = Promise.resolve();
+      return;
+    }
+    this.ready = import_signals_web.SignalsAgent.load(opts).then((loaded) => {
+      this.agentState.set(loaded);
+    }).catch((err) => {
+      this.loadErrorState.set(err instanceof Error ? err : new Error(String(err)));
+    });
+  }
+};
+
+// src/provide-signals.ts
+var import_common = require("@angular/common");
+var import_core3 = require("@angular/core");
+
+// src/tokens.ts
+var import_core2 = require("@angular/core");
+var SIGNALS_CLIENT = new import_core2.InjectionToken("signap.signals.client");
+
+// src/provide-signals.ts
+function provideSignals(opts) {
+  return (0, import_core3.makeEnvironmentProviders)([
+    {
+      provide: SIGNALS_CLIENT,
+      useFactory: () => new SignalsClient(opts, (0, import_common.isPlatformBrowser)((0, import_core3.inject)(import_core3.PLATFORM_ID)))
+    }
+  ]);
+}
+
+// src/inject-visitor-data.ts
+var import_core4 = require("@angular/core");
+function injectVisitorData(opts) {
+  (0, import_core4.assertInInjectionContext)(injectVisitorData);
+  const client = (0, import_core4.inject)(SIGNALS_CLIENT, { optional: true });
+  if (!client) {
+    throw new Error(
+      "[@signap/signals-angular] injectVisitorData() requires provideSignals() in the application (or component) providers"
+    );
+  }
+  const data = (0, import_core4.signal)(void 0);
+  const error = (0, import_core4.signal)(null);
+  const isLoading = (0, import_core4.signal)(client.agent() === null && client.loadError() === null);
+  let token = { cancelled: false };
+  (0, import_core4.inject)(import_core4.DestroyRef).onDestroy(() => {
+    token.cancelled = true;
+  });
+  const run = async () => {
+    const agent = client.agent();
+    if (!agent) {
+      const loadError = client.loadError();
+      if (loadError) {
+        error.set(loadError);
+        isLoading.set(false);
+      }
+      return;
+    }
+    token.cancelled = true;
+    const my = { cancelled: false };
+    token = my;
+    isLoading.set(true);
+    error.set(null);
+    data.set(void 0);
+    try {
+      const res = await agent.identify(opts);
+      if (my.cancelled) return;
+      data.set(res);
+    } catch (err) {
+      if (my.cancelled) return;
+      error.set(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      if (!my.cancelled) isLoading.set(false);
+    }
+  };
+  void client.ready.then(() => run());
+  return { data, isLoading, error, refetch: run };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SIGNALS_CLIENT,
+  SdkError,
+  SignalsClient,
+  WEB_SDK_VERSION,
+  injectVisitorData,
+  provideSignals
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/client.ts","../src/provide-signals.ts","../src/tokens.ts","../src/inject-visitor-data.ts"],"sourcesContent":["export {\n  type AgentLoadOptions,\n  type IdentifyOptions,\n  type IdentifyResult,\n  SdkError,\n  type SdkErrorCode,\n  VERSION as WEB_SDK_VERSION,\n} from \"@signap/signals-web\";\n\nexport { SignalsClient } from \"./client\";\nexport { provideSignals } from \"./provide-signals\";\nexport { SIGNALS_CLIENT } from \"./tokens\";\nexport {\n  injectVisitorData,\n  type InjectVisitorDataOptions,\n  type InjectVisitorDataResult,\n} from \"./inject-visitor-data\";\n","import { type Signal, signal } from \"@angular/core\";\nimport { type AgentLoadOptions, SignalsAgent } from \"@signap/signals-web\";\n\n/**\n * Holds a single lazily-loaded SignalsAgent and exposes its readiness as Angular\n * signals — the framework-native analog of the Vue wrapper's provide/inject refs\n * and the React wrapper's context. `agent()` is `null` until `SignalsAgent.load()`\n * settles; `loadError()` is non-null if it rejected (e.g. an invalid apiKey).\n *\n * Deliberately NOT `@Injectable`: a decorator-free class keeps this package\n * AOT-safe under a plain tsup build (no ngtsc / ng-packagr partial-Ivy metadata\n * step). It is wired into DI by the factory in `provideSignals()`.\n */\nexport class SignalsClient {\n  private readonly agentState = signal<SignalsAgent | null>(null);\n  private readonly loadErrorState = signal<Error | null>(null);\n\n  /** Resolved agent, or `null` until `SignalsAgent.load()` settles. */\n  readonly agent: Signal<SignalsAgent | null> = this.agentState.asReadonly();\n  /** Non-null if `SignalsAgent.load()` rejected. */\n  readonly loadError: Signal<Error | null> = this.loadErrorState.asReadonly();\n  /**\n   * Resolves once `load()` has settled (agent set OR loadError set). Lets\n   * `injectVisitorData()` await readiness without an Angular `effect`, so the\n   * auto-identify fires exactly once regardless of change-detection timing.\n   */\n  readonly ready: Promise<void>;\n\n  /**\n   * @param opts    forwarded verbatim to `SignalsAgent.load()`.\n   * @param browser whether we're running in a browser; `load()` only fires\n   *                client-side so SSR / prerender never touches\n   *                window/document/WebCrypto (the Angular analog of the Vue\n   *                plugin's `typeof window` guard).\n   */\n  constructor(opts: AgentLoadOptions, browser: boolean) {\n    if (!browser) {\n      this.ready = Promise.resolve();\n      return;\n    }\n    this.ready = SignalsAgent.load(opts)\n      .then((loaded) => {\n        this.agentState.set(loaded);\n      })\n      .catch((err: unknown) => {\n        this.loadErrorState.set(err instanceof Error ? err : new Error(String(err)));\n      });\n  }\n}\n","import { isPlatformBrowser } from \"@angular/common\";\nimport {\n  type EnvironmentProviders,\n  PLATFORM_ID,\n  inject,\n  makeEnvironmentProviders,\n} from \"@angular/core\";\nimport type { AgentLoadOptions } from \"@signap/signals-web\";\nimport { SignalsClient } from \"./client\";\nimport { SIGNALS_CLIENT } from \"./tokens\";\n\n/**\n * Registers a single app-wide SignalsAgent — the idiomatic standalone-Angular\n * entry point, analogous to React's `<SignalsProvider>` and Vue's\n * `app.use(SignalsPlugin)`:\n *\n * ```ts\n * bootstrapApplication(AppComponent, {\n *   providers: [\n *     provideSignals({ apiKey: \"pk_live_...\", endpoint: \"https://ingest.example\" }),\n *   ],\n * });\n * ```\n *\n * SSR-safe: the factory injects `PLATFORM_ID` and only lets the client call\n * `SignalsAgent.load()` in a browser, so a server render / prerender never loads\n * the agent.\n *\n * `opts` is snapshotted here at bootstrap; to swap apiKey/endpoint, re-bootstrap\n * (same snapshot-at-init contract as the React/Vue wrappers).\n */\nexport function provideSignals(opts: AgentLoadOptions): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {\n      provide: SIGNALS_CLIENT,\n      useFactory: () => new SignalsClient(opts, isPlatformBrowser(inject(PLATFORM_ID))),\n    },\n  ]);\n}\n","import { InjectionToken } from \"@angular/core\";\nimport type { SignalsClient } from \"./client\";\n\n/**\n * DI token the app-wide {@link SignalsClient} is registered under (by\n * `provideSignals()`) and that `injectVisitorData()` resolves. Most consumers\n * don't inject this directly — call `injectVisitorData()`. It is exported for\n * advanced use (e.g. `inject(SIGNALS_CLIENT).agent()` to read the raw agent).\n */\nexport const SIGNALS_CLIENT = new InjectionToken<SignalsClient>(\"signap.signals.client\");\n","import { DestroyRef, type Signal, assertInInjectionContext, inject, signal } from \"@angular/core\";\nimport type { IdentifyOptions, IdentifyResult } from \"@signap/signals-web\";\nimport { SIGNALS_CLIENT } from \"./tokens\";\n\nexport type InjectVisitorDataOptions = IdentifyOptions;\n\nexport interface InjectVisitorDataResult {\n  /**\n   * Resolved visitor from `agent.identify()`. Under ADR §A2 the call is a single\n   * synchronous round-trip — `visitorId`/`confidence`/`identifiedAt` arrive\n   * together, no polling. A `Signal`, so read it as `data()` (in a template or a\n   * `computed`/`effect`).\n   */\n  data: Signal<IdentifyResult | undefined>;\n  /** True between call time and the identify() resolution (or `error`). */\n  isLoading: Signal<boolean>;\n  error: Signal<Error | null>;\n  /** Re-run `agent.identify()` (e.g. from a button click). */\n  refetch: () => Promise<void>;\n}\n\n/**\n * Auto-identifies once the provider's agent is ready, then exposes the resolved\n * visitor as Angular signals — the framework-native analog of React's\n * `useVisitorData()` hook and Vue's `useVisitorData()` composable.\n *\n * Must be called in an injection context (a component/directive constructor or a\n * field initializer, or inside `runInInjectionContext`) below `provideSignals()`.\n */\nexport function injectVisitorData(opts?: InjectVisitorDataOptions): InjectVisitorDataResult {\n  assertInInjectionContext(injectVisitorData);\n\n  const client = inject(SIGNALS_CLIENT, { optional: true });\n  if (!client) {\n    throw new Error(\n      \"[@signap/signals-angular] injectVisitorData() requires provideSignals() in the application (or component) providers\",\n    );\n  }\n\n  const data = signal<IdentifyResult | undefined>(undefined);\n  const error = signal<Error | null>(null);\n  // Loading until the agent (or a load error) settles.\n  const isLoading = signal(client.agent() === null && client.loadError() === null);\n\n  // Supersede token so a slow response from a call that refetch() replaced (or a\n  // response arriving after teardown) is discarded.\n  let token = { cancelled: false };\n  inject(DestroyRef).onDestroy(() => {\n    token.cancelled = true;\n  });\n\n  const run = async (): Promise<void> => {\n    const agent = client.agent();\n    if (!agent) {\n      const loadError = client.loadError();\n      if (loadError) {\n        error.set(loadError);\n        isLoading.set(false);\n      }\n      return;\n    }\n    token.cancelled = true;\n    const my = { cancelled: false };\n    token = my;\n    isLoading.set(true);\n    error.set(null);\n    data.set(undefined);\n    try {\n      const res = await agent.identify(opts);\n      if (my.cancelled) return;\n      data.set(res);\n    } catch (err) {\n      if (my.cancelled) return;\n      error.set(err instanceof Error ? err : new Error(String(err)));\n    } finally {\n      if (!my.cancelled) isLoading.set(false);\n    }\n  };\n\n  // Auto-run exactly once, after load() settles. `ready` resolves whether load()\n  // succeeded or failed; even if it already resolved, `.then` defers to a\n  // microtask so the returned signals are wired up before the first run().\n  void client.ready.then(() => run());\n\n  return { data, isLoading, error, refetch: run };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAAA,sBAOO;;;ACPP,kBAAoC;AACpC,yBAAoD;AAY7C,IAAM,gBAAN,MAAoB;AAAA,EACR,iBAAa,oBAA4B,IAAI;AAAA,EAC7C,qBAAiB,oBAAqB,IAAI;AAAA;AAAA,EAGlD,QAAqC,KAAK,WAAW,WAAW;AAAA;AAAA,EAEhE,YAAkC,KAAK,eAAe,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMjE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAST,YAAY,MAAwB,SAAkB;AACpD,QAAI,CAAC,SAAS;AACZ,WAAK,QAAQ,QAAQ,QAAQ;AAC7B;AAAA,IACF;AACA,SAAK,QAAQ,gCAAa,KAAK,IAAI,EAChC,KAAK,CAAC,WAAW;AAChB,WAAK,WAAW,IAAI,MAAM;AAAA,IAC5B,CAAC,EACA,MAAM,CAAC,QAAiB;AACvB,WAAK,eAAe,IAAI,eAAe,QAAQ,MAAM,IAAI,MAAM,OAAO,GAAG,CAAC,CAAC;AAAA,IAC7E,CAAC;AAAA,EACL;AACF;;;AChDA,oBAAkC;AAClC,IAAAC,eAKO;;;ACNP,IAAAC,eAA+B;AASxB,IAAM,iBAAiB,IAAI,4BAA8B,uBAAuB;;;ADsBhF,SAAS,eAAe,MAA8C;AAC3E,aAAO,uCAAyB;AAAA,IAC9B;AAAA,MACE,SAAS;AAAA,MACT,YAAY,MAAM,IAAI,cAAc,UAAM,qCAAkB,qBAAO,wBAAW,CAAC,CAAC;AAAA,IAClF;AAAA,EACF,CAAC;AACH;;;AEtCA,IAAAC,eAAkF;AA6B3E,SAAS,kBAAkB,MAA0D;AAC1F,6CAAyB,iBAAiB;AAE1C,QAAM,aAAS,qBAAO,gBAAgB,EAAE,UAAU,KAAK,CAAC;AACxD,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,QAAM,WAAO,qBAAmC,MAAS;AACzD,QAAM,YAAQ,qBAAqB,IAAI;AAEvC,QAAM,gBAAY,qBAAO,OAAO,MAAM,MAAM,QAAQ,OAAO,UAAU,MAAM,IAAI;AAI/E,MAAI,QAAQ,EAAE,WAAW,MAAM;AAC/B,2BAAO,uBAAU,EAAE,UAAU,MAAM;AACjC,UAAM,YAAY;AAAA,EACpB,CAAC;AAED,QAAM,MAAM,YAA2B;AACrC,UAAM,QAAQ,OAAO,MAAM;AAC3B,QAAI,CAAC,OAAO;AACV,YAAM,YAAY,OAAO,UAAU;AACnC,UAAI,WAAW;AACb,cAAM,IAAI,SAAS;AACnB,kBAAU,IAAI,KAAK;AAAA,MACrB;AACA;AAAA,IACF;AACA,UAAM,YAAY;AAClB,UAAM,KAAK,EAAE,WAAW,MAAM;AAC9B,YAAQ;AACR,cAAU,IAAI,IAAI;AAClB,UAAM,IAAI,IAAI;AACd,SAAK,IAAI,MAAS;AAClB,QAAI;AACF,YAAM,MAAM,MAAM,MAAM,SAAS,IAAI;AACrC,UAAI,GAAG,UAAW;AAClB,WAAK,IAAI,GAAG;AAAA,IACd,SAAS,KAAK;AACZ,UAAI,GAAG,UAAW;AAClB,YAAM,IAAI,eAAe,QAAQ,MAAM,IAAI,MAAM,OAAO,GAAG,CAAC,CAAC;AAAA,IAC/D,UAAE;AACA,UAAI,CAAC,GAAG,UAAW,WAAU,IAAI,KAAK;AAAA,IACxC;AAAA,EACF;AAKA,OAAK,OAAO,MAAM,KAAK,MAAM,IAAI,CAAC;AAElC,SAAO,EAAE,MAAM,WAAW,OAAO,SAAS,IAAI;AAChD;","names":["import_signals_web","import_core","import_core","import_core"]}

package/dist/index.d.cts

@@ -0,0 +1,93 @@
+import { SignalsAgent, AgentLoadOptions, IdentifyOptions, IdentifyResult } from '@signap/signals-web';
+export { AgentLoadOptions, IdentifyOptions, IdentifyResult, SdkError, SdkErrorCode, VERSION as WEB_SDK_VERSION } from '@signap/signals-web';
+import { Signal, EnvironmentProviders, InjectionToken } from '@angular/core';
+
+/**
+ * Holds a single lazily-loaded SignalsAgent and exposes its readiness as Angular
+ * signals — the framework-native analog of the Vue wrapper's provide/inject refs
+ * and the React wrapper's context. `agent()` is `null` until `SignalsAgent.load()`
+ * settles; `loadError()` is non-null if it rejected (e.g. an invalid apiKey).
+ *
+ * Deliberately NOT `@Injectable`: a decorator-free class keeps this package
+ * AOT-safe under a plain tsup build (no ngtsc / ng-packagr partial-Ivy metadata
+ * step). It is wired into DI by the factory in `provideSignals()`.
+ */
+declare class SignalsClient {
+    private readonly agentState;
+    private readonly loadErrorState;
+    /** Resolved agent, or `null` until `SignalsAgent.load()` settles. */
+    readonly agent: Signal<SignalsAgent | null>;
+    /** Non-null if `SignalsAgent.load()` rejected. */
+    readonly loadError: Signal<Error | null>;
+    /**
+     * Resolves once `load()` has settled (agent set OR loadError set). Lets
+     * `injectVisitorData()` await readiness without an Angular `effect`, so the
+     * auto-identify fires exactly once regardless of change-detection timing.
+     */
+    readonly ready: Promise<void>;
+    /**
+     * @param opts    forwarded verbatim to `SignalsAgent.load()`.
+     * @param browser whether we're running in a browser; `load()` only fires
+     *                client-side so SSR / prerender never touches
+     *                window/document/WebCrypto (the Angular analog of the Vue
+     *                plugin's `typeof window` guard).
+     */
+    constructor(opts: AgentLoadOptions, browser: boolean);
+}
+
+/**
+ * Registers a single app-wide SignalsAgent — the idiomatic standalone-Angular
+ * entry point, analogous to React's `<SignalsProvider>` and Vue's
+ * `app.use(SignalsPlugin)`:
+ *
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideSignals({ apiKey: "pk_live_...", endpoint: "https://ingest.example" }),
+ *   ],
+ * });
+ * ```
+ *
+ * SSR-safe: the factory injects `PLATFORM_ID` and only lets the client call
+ * `SignalsAgent.load()` in a browser, so a server render / prerender never loads
+ * the agent.
+ *
+ * `opts` is snapshotted here at bootstrap; to swap apiKey/endpoint, re-bootstrap
+ * (same snapshot-at-init contract as the React/Vue wrappers).
+ */
+declare function provideSignals(opts: AgentLoadOptions): EnvironmentProviders;
+
+/**
+ * DI token the app-wide {@link SignalsClient} is registered under (by
+ * `provideSignals()`) and that `injectVisitorData()` resolves. Most consumers
+ * don't inject this directly — call `injectVisitorData()`. It is exported for
+ * advanced use (e.g. `inject(SIGNALS_CLIENT).agent()` to read the raw agent).
+ */
+declare const SIGNALS_CLIENT: InjectionToken<SignalsClient>;
+
+type InjectVisitorDataOptions = IdentifyOptions;
+interface InjectVisitorDataResult {
+    /**
+     * Resolved visitor from `agent.identify()`. Under ADR §A2 the call is a single
+     * synchronous round-trip — `visitorId`/`confidence`/`identifiedAt` arrive
+     * together, no polling. A `Signal`, so read it as `data()` (in a template or a
+     * `computed`/`effect`).
+     */
+    data: Signal<IdentifyResult | undefined>;
+    /** True between call time and the identify() resolution (or `error`). */
+    isLoading: Signal<boolean>;
+    error: Signal<Error | null>;
+    /** Re-run `agent.identify()` (e.g. from a button click). */
+    refetch: () => Promise<void>;
+}
+/**
+ * Auto-identifies once the provider's agent is ready, then exposes the resolved
+ * visitor as Angular signals — the framework-native analog of React's
+ * `useVisitorData()` hook and Vue's `useVisitorData()` composable.
+ *
+ * Must be called in an injection context (a component/directive constructor or a
+ * field initializer, or inside `runInInjectionContext`) below `provideSignals()`.
+ */
+declare function injectVisitorData(opts?: InjectVisitorDataOptions): InjectVisitorDataResult;
+
+export { type InjectVisitorDataOptions, type InjectVisitorDataResult, SIGNALS_CLIENT, SignalsClient, injectVisitorData, provideSignals };

package/dist/index.d.ts

@@ -0,0 +1,93 @@
+import { SignalsAgent, AgentLoadOptions, IdentifyOptions, IdentifyResult } from '@signap/signals-web';
+export { AgentLoadOptions, IdentifyOptions, IdentifyResult, SdkError, SdkErrorCode, VERSION as WEB_SDK_VERSION } from '@signap/signals-web';
+import { Signal, EnvironmentProviders, InjectionToken } from '@angular/core';
+
+/**
+ * Holds a single lazily-loaded SignalsAgent and exposes its readiness as Angular
+ * signals — the framework-native analog of the Vue wrapper's provide/inject refs
+ * and the React wrapper's context. `agent()` is `null` until `SignalsAgent.load()`
+ * settles; `loadError()` is non-null if it rejected (e.g. an invalid apiKey).
+ *
+ * Deliberately NOT `@Injectable`: a decorator-free class keeps this package
+ * AOT-safe under a plain tsup build (no ngtsc / ng-packagr partial-Ivy metadata
+ * step). It is wired into DI by the factory in `provideSignals()`.
+ */
+declare class SignalsClient {
+    private readonly agentState;
+    private readonly loadErrorState;
+    /** Resolved agent, or `null` until `SignalsAgent.load()` settles. */
+    readonly agent: Signal<SignalsAgent | null>;
+    /** Non-null if `SignalsAgent.load()` rejected. */
+    readonly loadError: Signal<Error | null>;
+    /**
+     * Resolves once `load()` has settled (agent set OR loadError set). Lets
+     * `injectVisitorData()` await readiness without an Angular `effect`, so the
+     * auto-identify fires exactly once regardless of change-detection timing.
+     */
+    readonly ready: Promise<void>;
+    /**
+     * @param opts    forwarded verbatim to `SignalsAgent.load()`.
+     * @param browser whether we're running in a browser; `load()` only fires
+     *                client-side so SSR / prerender never touches
+     *                window/document/WebCrypto (the Angular analog of the Vue
+     *                plugin's `typeof window` guard).
+     */
+    constructor(opts: AgentLoadOptions, browser: boolean);
+}
+
+/**
+ * Registers a single app-wide SignalsAgent — the idiomatic standalone-Angular
+ * entry point, analogous to React's `<SignalsProvider>` and Vue's
+ * `app.use(SignalsPlugin)`:
+ *
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideSignals({ apiKey: "pk_live_...", endpoint: "https://ingest.example" }),
+ *   ],
+ * });
+ * ```
+ *
+ * SSR-safe: the factory injects `PLATFORM_ID` and only lets the client call
+ * `SignalsAgent.load()` in a browser, so a server render / prerender never loads
+ * the agent.
+ *
+ * `opts` is snapshotted here at bootstrap; to swap apiKey/endpoint, re-bootstrap
+ * (same snapshot-at-init contract as the React/Vue wrappers).
+ */
+declare function provideSignals(opts: AgentLoadOptions): EnvironmentProviders;
+
+/**
+ * DI token the app-wide {@link SignalsClient} is registered under (by
+ * `provideSignals()`) and that `injectVisitorData()` resolves. Most consumers
+ * don't inject this directly — call `injectVisitorData()`. It is exported for
+ * advanced use (e.g. `inject(SIGNALS_CLIENT).agent()` to read the raw agent).
+ */
+declare const SIGNALS_CLIENT: InjectionToken<SignalsClient>;
+
+type InjectVisitorDataOptions = IdentifyOptions;
+interface InjectVisitorDataResult {
+    /**
+     * Resolved visitor from `agent.identify()`. Under ADR §A2 the call is a single
+     * synchronous round-trip — `visitorId`/`confidence`/`identifiedAt` arrive
+     * together, no polling. A `Signal`, so read it as `data()` (in a template or a
+     * `computed`/`effect`).
+     */
+    data: Signal<IdentifyResult | undefined>;
+    /** True between call time and the identify() resolution (or `error`). */
+    isLoading: Signal<boolean>;
+    error: Signal<Error | null>;
+    /** Re-run `agent.identify()` (e.g. from a button click). */
+    refetch: () => Promise<void>;
+}
+/**
+ * Auto-identifies once the provider's agent is ready, then exposes the resolved
+ * visitor as Angular signals — the framework-native analog of React's
+ * `useVisitorData()` hook and Vue's `useVisitorData()` composable.
+ *
+ * Must be called in an injection context (a component/directive constructor or a
+ * field initializer, or inside `runInInjectionContext`) below `provideSignals()`.
+ */
+declare function injectVisitorData(opts?: InjectVisitorDataOptions): InjectVisitorDataResult;
+
+export { type InjectVisitorDataOptions, type InjectVisitorDataResult, SIGNALS_CLIENT, SignalsClient, injectVisitorData, provideSignals };

package/dist/index.js

@@ -0,0 +1,120 @@
+// src/index.ts
+import {
+  SdkError,
+  VERSION
+} from "@signap/signals-web";
+
+// src/client.ts
+import { signal } from "@angular/core";
+import { SignalsAgent } from "@signap/signals-web";
+var SignalsClient = class {
+  agentState = signal(null);
+  loadErrorState = signal(null);
+  /** Resolved agent, or `null` until `SignalsAgent.load()` settles. */
+  agent = this.agentState.asReadonly();
+  /** Non-null if `SignalsAgent.load()` rejected. */
+  loadError = this.loadErrorState.asReadonly();
+  /**
+   * Resolves once `load()` has settled (agent set OR loadError set). Lets
+   * `injectVisitorData()` await readiness without an Angular `effect`, so the
+   * auto-identify fires exactly once regardless of change-detection timing.
+   */
+  ready;
+  /**
+   * @param opts    forwarded verbatim to `SignalsAgent.load()`.
+   * @param browser whether we're running in a browser; `load()` only fires
+   *                client-side so SSR / prerender never touches
+   *                window/document/WebCrypto (the Angular analog of the Vue
+   *                plugin's `typeof window` guard).
+   */
+  constructor(opts, browser) {
+    if (!browser) {
+      this.ready = Promise.resolve();
+      return;
+    }
+    this.ready = SignalsAgent.load(opts).then((loaded) => {
+      this.agentState.set(loaded);
+    }).catch((err) => {
+      this.loadErrorState.set(err instanceof Error ? err : new Error(String(err)));
+    });
+  }
+};
+
+// src/provide-signals.ts
+import { isPlatformBrowser } from "@angular/common";
+import {
+  PLATFORM_ID,
+  inject,
+  makeEnvironmentProviders
+} from "@angular/core";
+
+// src/tokens.ts
+import { InjectionToken } from "@angular/core";
+var SIGNALS_CLIENT = new InjectionToken("signap.signals.client");
+
+// src/provide-signals.ts
+function provideSignals(opts) {
+  return makeEnvironmentProviders([
+    {
+      provide: SIGNALS_CLIENT,
+      useFactory: () => new SignalsClient(opts, isPlatformBrowser(inject(PLATFORM_ID)))
+    }
+  ]);
+}
+
+// src/inject-visitor-data.ts
+import { DestroyRef, assertInInjectionContext, inject as inject2, signal as signal2 } from "@angular/core";
+function injectVisitorData(opts) {
+  assertInInjectionContext(injectVisitorData);
+  const client = inject2(SIGNALS_CLIENT, { optional: true });
+  if (!client) {
+    throw new Error(
+      "[@signap/signals-angular] injectVisitorData() requires provideSignals() in the application (or component) providers"
+    );
+  }
+  const data = signal2(void 0);
+  const error = signal2(null);
+  const isLoading = signal2(client.agent() === null && client.loadError() === null);
+  let token = { cancelled: false };
+  inject2(DestroyRef).onDestroy(() => {
+    token.cancelled = true;
+  });
+  const run = async () => {
+    const agent = client.agent();
+    if (!agent) {
+      const loadError = client.loadError();
+      if (loadError) {
+        error.set(loadError);
+        isLoading.set(false);
+      }
+      return;
+    }
+    token.cancelled = true;
+    const my = { cancelled: false };
+    token = my;
+    isLoading.set(true);
+    error.set(null);
+    data.set(void 0);
+    try {
+      const res = await agent.identify(opts);
+      if (my.cancelled) return;
+      data.set(res);
+    } catch (err) {
+      if (my.cancelled) return;
+      error.set(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      if (!my.cancelled) isLoading.set(false);
+    }
+  };
+  void client.ready.then(() => run());
+  return { data, isLoading, error, refetch: run };
+}
+export {
+  SIGNALS_CLIENT,
+  SdkError,
+  SignalsClient,
+  VERSION as WEB_SDK_VERSION,
+  injectVisitorData,
+  provideSignals
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/client.ts","../src/provide-signals.ts","../src/tokens.ts","../src/inject-visitor-data.ts"],"sourcesContent":["export {\n  type AgentLoadOptions,\n  type IdentifyOptions,\n  type IdentifyResult,\n  SdkError,\n  type SdkErrorCode,\n  VERSION as WEB_SDK_VERSION,\n} from \"@signap/signals-web\";\n\nexport { SignalsClient } from \"./client\";\nexport { provideSignals } from \"./provide-signals\";\nexport { SIGNALS_CLIENT } from \"./tokens\";\nexport {\n  injectVisitorData,\n  type InjectVisitorDataOptions,\n  type InjectVisitorDataResult,\n} from \"./inject-visitor-data\";\n","import { type Signal, signal } from \"@angular/core\";\nimport { type AgentLoadOptions, SignalsAgent } from \"@signap/signals-web\";\n\n/**\n * Holds a single lazily-loaded SignalsAgent and exposes its readiness as Angular\n * signals — the framework-native analog of the Vue wrapper's provide/inject refs\n * and the React wrapper's context. `agent()` is `null` until `SignalsAgent.load()`\n * settles; `loadError()` is non-null if it rejected (e.g. an invalid apiKey).\n *\n * Deliberately NOT `@Injectable`: a decorator-free class keeps this package\n * AOT-safe under a plain tsup build (no ngtsc / ng-packagr partial-Ivy metadata\n * step). It is wired into DI by the factory in `provideSignals()`.\n */\nexport class SignalsClient {\n  private readonly agentState = signal<SignalsAgent | null>(null);\n  private readonly loadErrorState = signal<Error | null>(null);\n\n  /** Resolved agent, or `null` until `SignalsAgent.load()` settles. */\n  readonly agent: Signal<SignalsAgent | null> = this.agentState.asReadonly();\n  /** Non-null if `SignalsAgent.load()` rejected. */\n  readonly loadError: Signal<Error | null> = this.loadErrorState.asReadonly();\n  /**\n   * Resolves once `load()` has settled (agent set OR loadError set). Lets\n   * `injectVisitorData()` await readiness without an Angular `effect`, so the\n   * auto-identify fires exactly once regardless of change-detection timing.\n   */\n  readonly ready: Promise<void>;\n\n  /**\n   * @param opts    forwarded verbatim to `SignalsAgent.load()`.\n   * @param browser whether we're running in a browser; `load()` only fires\n   *                client-side so SSR / prerender never touches\n   *                window/document/WebCrypto (the Angular analog of the Vue\n   *                plugin's `typeof window` guard).\n   */\n  constructor(opts: AgentLoadOptions, browser: boolean) {\n    if (!browser) {\n      this.ready = Promise.resolve();\n      return;\n    }\n    this.ready = SignalsAgent.load(opts)\n      .then((loaded) => {\n        this.agentState.set(loaded);\n      })\n      .catch((err: unknown) => {\n        this.loadErrorState.set(err instanceof Error ? err : new Error(String(err)));\n      });\n  }\n}\n","import { isPlatformBrowser } from \"@angular/common\";\nimport {\n  type EnvironmentProviders,\n  PLATFORM_ID,\n  inject,\n  makeEnvironmentProviders,\n} from \"@angular/core\";\nimport type { AgentLoadOptions } from \"@signap/signals-web\";\nimport { SignalsClient } from \"./client\";\nimport { SIGNALS_CLIENT } from \"./tokens\";\n\n/**\n * Registers a single app-wide SignalsAgent — the idiomatic standalone-Angular\n * entry point, analogous to React's `<SignalsProvider>` and Vue's\n * `app.use(SignalsPlugin)`:\n *\n * ```ts\n * bootstrapApplication(AppComponent, {\n *   providers: [\n *     provideSignals({ apiKey: \"pk_live_...\", endpoint: \"https://ingest.example\" }),\n *   ],\n * });\n * ```\n *\n * SSR-safe: the factory injects `PLATFORM_ID` and only lets the client call\n * `SignalsAgent.load()` in a browser, so a server render / prerender never loads\n * the agent.\n *\n * `opts` is snapshotted here at bootstrap; to swap apiKey/endpoint, re-bootstrap\n * (same snapshot-at-init contract as the React/Vue wrappers).\n */\nexport function provideSignals(opts: AgentLoadOptions): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {\n      provide: SIGNALS_CLIENT,\n      useFactory: () => new SignalsClient(opts, isPlatformBrowser(inject(PLATFORM_ID))),\n    },\n  ]);\n}\n","import { InjectionToken } from \"@angular/core\";\nimport type { SignalsClient } from \"./client\";\n\n/**\n * DI token the app-wide {@link SignalsClient} is registered under (by\n * `provideSignals()`) and that `injectVisitorData()` resolves. Most consumers\n * don't inject this directly — call `injectVisitorData()`. It is exported for\n * advanced use (e.g. `inject(SIGNALS_CLIENT).agent()` to read the raw agent).\n */\nexport const SIGNALS_CLIENT = new InjectionToken<SignalsClient>(\"signap.signals.client\");\n","import { DestroyRef, type Signal, assertInInjectionContext, inject, signal } from \"@angular/core\";\nimport type { IdentifyOptions, IdentifyResult } from \"@signap/signals-web\";\nimport { SIGNALS_CLIENT } from \"./tokens\";\n\nexport type InjectVisitorDataOptions = IdentifyOptions;\n\nexport interface InjectVisitorDataResult {\n  /**\n   * Resolved visitor from `agent.identify()`. Under ADR §A2 the call is a single\n   * synchronous round-trip — `visitorId`/`confidence`/`identifiedAt` arrive\n   * together, no polling. A `Signal`, so read it as `data()` (in a template or a\n   * `computed`/`effect`).\n   */\n  data: Signal<IdentifyResult | undefined>;\n  /** True between call time and the identify() resolution (or `error`). */\n  isLoading: Signal<boolean>;\n  error: Signal<Error | null>;\n  /** Re-run `agent.identify()` (e.g. from a button click). */\n  refetch: () => Promise<void>;\n}\n\n/**\n * Auto-identifies once the provider's agent is ready, then exposes the resolved\n * visitor as Angular signals — the framework-native analog of React's\n * `useVisitorData()` hook and Vue's `useVisitorData()` composable.\n *\n * Must be called in an injection context (a component/directive constructor or a\n * field initializer, or inside `runInInjectionContext`) below `provideSignals()`.\n */\nexport function injectVisitorData(opts?: InjectVisitorDataOptions): InjectVisitorDataResult {\n  assertInInjectionContext(injectVisitorData);\n\n  const client = inject(SIGNALS_CLIENT, { optional: true });\n  if (!client) {\n    throw new Error(\n      \"[@signap/signals-angular] injectVisitorData() requires provideSignals() in the application (or component) providers\",\n    );\n  }\n\n  const data = signal<IdentifyResult | undefined>(undefined);\n  const error = signal<Error | null>(null);\n  // Loading until the agent (or a load error) settles.\n  const isLoading = signal(client.agent() === null && client.loadError() === null);\n\n  // Supersede token so a slow response from a call that refetch() replaced (or a\n  // response arriving after teardown) is discarded.\n  let token = { cancelled: false };\n  inject(DestroyRef).onDestroy(() => {\n    token.cancelled = true;\n  });\n\n  const run = async (): Promise<void> => {\n    const agent = client.agent();\n    if (!agent) {\n      const loadError = client.loadError();\n      if (loadError) {\n        error.set(loadError);\n        isLoading.set(false);\n      }\n      return;\n    }\n    token.cancelled = true;\n    const my = { cancelled: false };\n    token = my;\n    isLoading.set(true);\n    error.set(null);\n    data.set(undefined);\n    try {\n      const res = await agent.identify(opts);\n      if (my.cancelled) return;\n      data.set(res);\n    } catch (err) {\n      if (my.cancelled) return;\n      error.set(err instanceof Error ? err : new Error(String(err)));\n    } finally {\n      if (!my.cancelled) isLoading.set(false);\n    }\n  };\n\n  // Auto-run exactly once, after load() settles. `ready` resolves whether load()\n  // succeeded or failed; even if it already resolved, `.then` defers to a\n  // microtask so the returned signals are wired up before the first run().\n  void client.ready.then(() => run());\n\n  return { data, isLoading, error, refetch: run };\n}\n"],"mappings":";AAAA;AAAA,EAIE;AAAA,EAEW;AAAA,OACN;;;ACPP,SAAsB,cAAc;AACpC,SAAgC,oBAAoB;AAY7C,IAAM,gBAAN,MAAoB;AAAA,EACR,aAAa,OAA4B,IAAI;AAAA,EAC7C,iBAAiB,OAAqB,IAAI;AAAA;AAAA,EAGlD,QAAqC,KAAK,WAAW,WAAW;AAAA;AAAA,EAEhE,YAAkC,KAAK,eAAe,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMjE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAST,YAAY,MAAwB,SAAkB;AACpD,QAAI,CAAC,SAAS;AACZ,WAAK,QAAQ,QAAQ,QAAQ;AAC7B;AAAA,IACF;AACA,SAAK,QAAQ,aAAa,KAAK,IAAI,EAChC,KAAK,CAAC,WAAW;AAChB,WAAK,WAAW,IAAI,MAAM;AAAA,IAC5B,CAAC,EACA,MAAM,CAAC,QAAiB;AACvB,WAAK,eAAe,IAAI,eAAe,QAAQ,MAAM,IAAI,MAAM,OAAO,GAAG,CAAC,CAAC;AAAA,IAC7E,CAAC;AAAA,EACL;AACF;;;AChDA,SAAS,yBAAyB;AAClC;AAAA,EAEE;AAAA,EACA;AAAA,EACA;AAAA,OACK;;;ACNP,SAAS,sBAAsB;AASxB,IAAM,iBAAiB,IAAI,eAA8B,uBAAuB;;;ADsBhF,SAAS,eAAe,MAA8C;AAC3E,SAAO,yBAAyB;AAAA,IAC9B;AAAA,MACE,SAAS;AAAA,MACT,YAAY,MAAM,IAAI,cAAc,MAAM,kBAAkB,OAAO,WAAW,CAAC,CAAC;AAAA,IAClF;AAAA,EACF,CAAC;AACH;;;AEtCA,SAAS,YAAyB,0BAA0B,UAAAA,SAAQ,UAAAC,eAAc;AA6B3E,SAAS,kBAAkB,MAA0D;AAC1F,2BAAyB,iBAAiB;AAE1C,QAAM,SAASC,QAAO,gBAAgB,EAAE,UAAU,KAAK,CAAC;AACxD,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,QAAM,OAAOC,QAAmC,MAAS;AACzD,QAAM,QAAQA,QAAqB,IAAI;AAEvC,QAAM,YAAYA,QAAO,OAAO,MAAM,MAAM,QAAQ,OAAO,UAAU,MAAM,IAAI;AAI/E,MAAI,QAAQ,EAAE,WAAW,MAAM;AAC/B,EAAAD,QAAO,UAAU,EAAE,UAAU,MAAM;AACjC,UAAM,YAAY;AAAA,EACpB,CAAC;AAED,QAAM,MAAM,YAA2B;AACrC,UAAM,QAAQ,OAAO,MAAM;AAC3B,QAAI,CAAC,OAAO;AACV,YAAM,YAAY,OAAO,UAAU;AACnC,UAAI,WAAW;AACb,cAAM,IAAI,SAAS;AACnB,kBAAU,IAAI,KAAK;AAAA,MACrB;AACA;AAAA,IACF;AACA,UAAM,YAAY;AAClB,UAAM,KAAK,EAAE,WAAW,MAAM;AAC9B,YAAQ;AACR,cAAU,IAAI,IAAI;AAClB,UAAM,IAAI,IAAI;AACd,SAAK,IAAI,MAAS;AAClB,QAAI;AACF,YAAM,MAAM,MAAM,MAAM,SAAS,IAAI;AACrC,UAAI,GAAG,UAAW;AAClB,WAAK,IAAI,GAAG;AAAA,IACd,SAAS,KAAK;AACZ,UAAI,GAAG,UAAW;AAClB,YAAM,IAAI,eAAe,QAAQ,MAAM,IAAI,MAAM,OAAO,GAAG,CAAC,CAAC;AAAA,IAC/D,UAAE;AACA,UAAI,CAAC,GAAG,UAAW,WAAU,IAAI,KAAK;AAAA,IACxC;AAAA,EACF;AAKA,OAAK,OAAO,MAAM,KAAK,MAAM,IAAI,CAAC;AAElC,SAAO,EAAE,MAAM,WAAW,OAAO,SAAS,IAAI;AAChD;","names":["inject","signal","inject","signal"]}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@signap/signals-angular",
+  "version": "2.0.0",
+  "description": "Angular provider + inject() helper wrapper for @signap/signals-web",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "peerDependencies": {
+    "@angular/common": ">=17 <21",
+    "@angular/core": ">=17 <21"
+  },
+  "dependencies": {
+    "@signap/signals-web": "2.2.0"
+  },
+  "devDependencies": {
+    "@angular/common": "^19.0.0",
+    "@angular/compiler": "^19.0.0",
+    "@angular/core": "^19.0.0",
+    "@angular/platform-browser": "^19.0.0",
+    "@angular/platform-browser-dynamic": "^19.0.0",
+    "@biomejs/biome": "^1.9.0",
+    "happy-dom": "^15.11.0",
+    "rxjs": "^7.8.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0",
+    "zone.js": "^0.15.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "Apache-2.0",
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src test"
+  }
+}