@vaadin/hilla-react-signals 24.5.0-alpha8 → 24.5.0-beta1

package/FullStackSignal.d.ts

@@ -0,0 +1,101 @@
+import type { ConnectClient, Subscription } from '@vaadin/hilla-frontend';
+import { Signal } from './core.js';
+import { type StateEvent } from './events.js';
+/**
+ * An abstraction of a signal that tracks the number of subscribers, and calls
+ * the provided `onSubscribe` and `onUnsubscribe` callbacks for the first
+ * subscription and the last unsubscription, respectively.
+ * @internal
+ */
+export declare abstract class DependencyTrackingSignal<T> extends Signal<T> {
+    #private;
+    protected constructor(value: T | undefined, onFirstSubscribe: () => void, onLastUnsubscribe: () => void);
+    protected S(node: unknown): void;
+    protected U(node: unknown): void;
+}
+/**
+ * An object that describes a data object to connect to the signal provider
+ * service.
+ */
+export type ServerConnectionConfig = Readonly<{
+    /**
+     * The client instance to be used for communication.
+     */
+    client: ConnectClient;
+    /**
+     * The name of the signal provider service endpoint.
+     */
+    endpoint: string;
+    /**
+     * The name of the signal provider service method.
+     */
+    method: string;
+    /**
+     * Optional object with method call arguments to be sent to the endpoint
+     * method that provides the signal when subscribing to it.
+     */
+    params?: Record<string, unknown>;
+}>;
+/**
+ * A server connection manager.
+ */
+declare class ServerConnection<T> {
+    #private;
+    constructor(id: string, config: ServerConnectionConfig);
+    get subscription(): Subscription<StateEvent<T>> | undefined;
+    connect(): Subscription<StateEvent<T>>;
+    update(event: StateEvent<T>): Promise<void>;
+    disconnect(): void;
+}
+export declare const $update: unique symbol;
+export declare const $processServerResponse: unique symbol;
+/**
+ * A signal that holds a shared value. Each change to the value is propagated to
+ * the server-side signal provider. At the same time, each change received from
+ * the server-side signal provider is propagated to the local signal and it's
+ * subscribers.
+ *
+ * @internal
+ */
+export declare abstract class FullStackSignal<T> extends DependencyTrackingSignal<T> {
+    #private;
+    /**
+     * The unique identifier of the signal necessary to communicate with the
+     * server.
+     */
+    readonly id: string;
+    /**
+     * The server connection manager.
+     */
+    readonly server: ServerConnection<T>;
+    /**
+     * Defines whether the signal is currently awaits a server-side response.
+     */
+    readonly pending: import("@preact/signals-core").ReadonlySignal<boolean>;
+    /**
+     * Defines whether the signal has an error.
+     */
+    readonly error: import("@preact/signals-core").ReadonlySignal<Error | undefined>;
+    constructor(value: T | undefined, config: ServerConnectionConfig);
+    /**
+     * Sets the local value of the signal without sending any events to the server
+     * @param value - The new value.
+     * @internal
+     */
+    protected setValueLocal(value: T): void;
+    /**
+     * A method to update the server with the new value.
+     *
+     * @param event - The event to update the server with.
+     */
+    protected [$update](event: StateEvent<T>): void;
+    /**
+     * A method with to process the server response. The implementation is
+     * specific for each signal type.
+     *
+     * @param event - The server response event.
+     */
+    protected abstract [$processServerResponse](event: StateEvent<T>): void;
+}
+export {};
+//# sourceMappingURL=FullStackSignal.d.ts.map

package/FullStackSignal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FullStackSignal.d.ts","sourceRoot":"","sources":["src/FullStackSignal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE1E,OAAO,EAAoB,MAAM,EAAE,MAAM,WAAW,CAAC;AACrD,OAAO,EAAuB,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAInE;;;;;GAKG;AACH,8BAAsB,wBAAwB,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;;IAQjE,SAAS,aAAa,KAAK,EAAE,CAAC,GAAG,SAAS,EAAE,gBAAgB,EAAE,MAAM,IAAI,EAAE,iBAAiB,EAAE,MAAM,IAAI;cAMpF,CAAC,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;cAQtB,CAAC,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;CAO1C;AAED;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C;;OAEG;IACH,MAAM,EAAE,aAAa,CAAC;IAEtB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC,CAAC,CAAC;AAEH;;GAEG;AACH,cAAM,gBAAgB,CAAC,CAAC;;gBAKV,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,sBAAsB;IAKtD,IAAI,YAAY,4CAEf;IAED,OAAO;IAaD,MAAM,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAOjD,UAAU;CAIX;AAED,eAAO,MAAM,OAAO,eAAmB,CAAC;AACxC,eAAO,MAAM,sBAAsB,eAAkC,CAAC;AAEtE;;;;;;;GAOG;AACH,8BAAsB,eAAe,CAAC,CAAC,CAAE,SAAQ,wBAAwB,CAAC,CAAC,CAAC;;IAC1E;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAY;IAEvB;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAErC;;OAEG;IACH,QAAQ,CAAC,OAAO,yDAAuC;IAEvD;;OAEG;IACH,QAAQ,CAAC,KAAK,mEAAqC;gBASvC,KAAK,EAAE,CAAC,GAAG,SAAS,EAAE,MAAM,EAAE,sBAAsB;IAmBhE;;;;OAIG;IACH,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAMvC;;;;OAIG;IACH,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI;IAW/C;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,CAAC,sBAAsB,CAAC,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI;CAgBxE"}

package/FullStackSignal.js

@@ -0,0 +1,146 @@
+import { nanoid } from "nanoid";
+import { computed, signal, Signal } from "./core.js";
+import { createSetStateEvent } from "./events.js";
+const ENDPOINT = "SignalsHandler";
+class DependencyTrackingSignal extends Signal {
+  #onFirstSubscribe;
+  #onLastUnsubscribe;
+  // -1 means to ignore the first subscription that is created internally in the
+  // FullStackSignal constructor.
+  #subscribeCount = -1;
+  constructor(value, onFirstSubscribe, onLastUnsubscribe) {
+    super(value);
+    this.#onFirstSubscribe = onFirstSubscribe;
+    this.#onLastUnsubscribe = onLastUnsubscribe;
+  }
+  S(node) {
+    super.S(node);
+    if (this.#subscribeCount === 0) {
+      this.#onFirstSubscribe();
+    }
+    this.#subscribeCount += 1;
+  }
+  U(node) {
+    super.U(node);
+    this.#subscribeCount -= 1;
+    if (this.#subscribeCount === 0) {
+      this.#onLastUnsubscribe();
+    }
+  }
+}
+class ServerConnection {
+  #id;
+  #config;
+  #subscription;
+  constructor(id, config) {
+    this.#config = config;
+    this.#id = id;
+  }
+  get subscription() {
+    return this.#subscription;
+  }
+  connect() {
+    const { client, endpoint, method, params } = this.#config;
+    this.#subscription ??= client.subscribe(ENDPOINT, "subscribe", {
+      providerEndpoint: endpoint,
+      providerMethod: method,
+      clientSignalId: this.#id,
+      params
+    });
+    return this.#subscription;
+  }
+  async update(event) {
+    await this.#config.client.call(ENDPOINT, "update", {
+      clientSignalId: this.#id,
+      event
+    });
+  }
+  disconnect() {
+    this.#subscription?.cancel();
+    this.#subscription = void 0;
+  }
+}
+const $update = Symbol("update");
+const $processServerResponse = Symbol("processServerResponse");
+class FullStackSignal extends DependencyTrackingSignal {
+  /**
+   * The unique identifier of the signal necessary to communicate with the
+   * server.
+   */
+  id = nanoid();
+  /**
+   * The server connection manager.
+   */
+  server;
+  /**
+   * Defines whether the signal is currently awaits a server-side response.
+   */
+  pending = computed(() => this.#pending.value);
+  /**
+   * Defines whether the signal has an error.
+   */
+  error = computed(() => this.#error.value);
+  #pending = signal(false);
+  #error = signal(void 0);
+  // Paused at the very start to prevent the signal from sending the initial
+  // value to the server.
+  #paused = true;
+  constructor(value, config) {
+    super(
+      value,
+      () => this.#connect(),
+      () => this.#disconnect()
+    );
+    this.server = new ServerConnection(this.id, config);
+    this.subscribe((v) => {
+      if (!this.#paused) {
+        this.#pending.value = true;
+        this.#error.value = void 0;
+        this[$update](createSetStateEvent(v));
+      }
+    });
+    this.#paused = false;
+  }
+  /**
+   * Sets the local value of the signal without sending any events to the server
+   * @param value - The new value.
+   * @internal
+   */
+  setValueLocal(value) {
+    this.#paused = true;
+    this.value = value;
+    this.#paused = false;
+  }
+  /**
+   * A method to update the server with the new value.
+   *
+   * @param event - The event to update the server with.
+   */
+  [$update](event) {
+    this.server.update(event).catch((error) => {
+      this.#error.value = error instanceof Error ? error : new Error(String(error));
+    }).finally(() => {
+      this.#pending.value = false;
+    });
+  }
+  #connect() {
+    this.server.connect().onNext((event) => {
+      this.#paused = true;
+      this[$processServerResponse](event);
+      this.#paused = false;
+    });
+  }
+  #disconnect() {
+    if (this.server.subscription === void 0) {
+      return;
+    }
+    this.server.disconnect();
+  }
+}
+export {
+  $processServerResponse,
+  $update,
+  DependencyTrackingSignal,
+  FullStackSignal
+};
+//# sourceMappingURL=FullStackSignal.js.map

package/FullStackSignal.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/FullStackSignal.ts"],
+  "sourcesContent": ["import type { ConnectClient, Subscription } from '@vaadin/hilla-frontend';\nimport { nanoid } from 'nanoid';\nimport { computed, signal, Signal } from './core.js';\nimport { createSetStateEvent, type StateEvent } from './events.js';\n\nconst ENDPOINT = 'SignalsHandler';\n\n/**\n * An abstraction of a signal that tracks the number of subscribers, and calls\n * the provided `onSubscribe` and `onUnsubscribe` callbacks for the first\n * subscription and the last unsubscription, respectively.\n * @internal\n */\nexport abstract class DependencyTrackingSignal<T> extends Signal<T> {\n  readonly #onFirstSubscribe: () => void;\n  readonly #onLastUnsubscribe: () => void;\n\n  // -1 means to ignore the first subscription that is created internally in the\n  // FullStackSignal constructor.\n  #subscribeCount = -1;\n\n  protected constructor(value: T | undefined, onFirstSubscribe: () => void, onLastUnsubscribe: () => void) {\n    super(value);\n    this.#onFirstSubscribe = onFirstSubscribe;\n    this.#onLastUnsubscribe = onLastUnsubscribe;\n  }\n\n  protected override S(node: unknown): void {\n    super.S(node);\n    if (this.#subscribeCount === 0) {\n      this.#onFirstSubscribe();\n    }\n    this.#subscribeCount += 1;\n  }\n\n  protected override U(node: unknown): void {\n    super.U(node);\n    this.#subscribeCount -= 1;\n    if (this.#subscribeCount === 0) {\n      this.#onLastUnsubscribe();\n    }\n  }\n}\n\n/**\n * An object that describes a data object to connect to the signal provider\n * service.\n */\nexport type ServerConnectionConfig = Readonly<{\n  /**\n   * The client instance to be used for communication.\n   */\n  client: ConnectClient;\n\n  /**\n   * The name of the signal provider service endpoint.\n   */\n  endpoint: string;\n\n  /**\n   * The name of the signal provider service method.\n   */\n  method: string;\n\n  /**\n   * Optional object with method call arguments to be sent to the endpoint\n   * method that provides the signal when subscribing to it.\n   */\n  params?: Record<string, unknown>;\n}>;\n\n/**\n * A server connection manager.\n */\nclass ServerConnection<T> {\n  readonly #id: string;\n  readonly #config: ServerConnectionConfig;\n  #subscription?: Subscription<StateEvent<T>>;\n\n  constructor(id: string, config: ServerConnectionConfig) {\n    this.#config = config;\n    this.#id = id;\n  }\n\n  get subscription() {\n    return this.#subscription;\n  }\n\n  connect() {\n    const { client, endpoint, method, params } = this.#config;\n\n    this.#subscription ??= client.subscribe(ENDPOINT, 'subscribe', {\n      providerEndpoint: endpoint,\n      providerMethod: method,\n      clientSignalId: this.#id,\n      params,\n    });\n\n    return this.#subscription;\n  }\n\n  async update(event: StateEvent<T>): Promise<void> {\n    await this.#config.client.call(ENDPOINT, 'update', {\n      clientSignalId: this.#id,\n      event,\n    });\n  }\n\n  disconnect() {\n    this.#subscription?.cancel();\n    this.#subscription = undefined;\n  }\n}\n\nexport const $update = Symbol('update');\nexport const $processServerResponse = Symbol('processServerResponse');\n\n/**\n * A signal that holds a shared value. Each change to the value is propagated to\n * the server-side signal provider. At the same time, each change received from\n * the server-side signal provider is propagated to the local signal and it's\n * subscribers.\n *\n * @internal\n */\nexport abstract class FullStackSignal<T> extends DependencyTrackingSignal<T> {\n  /**\n   * The unique identifier of the signal necessary to communicate with the\n   * server.\n   */\n  readonly id = nanoid();\n\n  /**\n   * The server connection manager.\n   */\n  readonly server: ServerConnection<T>;\n\n  /**\n   * Defines whether the signal is currently awaits a server-side response.\n   */\n  readonly pending = computed(() => this.#pending.value);\n\n  /**\n   * Defines whether the signal has an error.\n   */\n  readonly error = computed(() => this.#error.value);\n\n  readonly #pending = signal(false);\n  readonly #error = signal<Error | undefined>(undefined);\n\n  // Paused at the very start to prevent the signal from sending the initial\n  // value to the server.\n  #paused = true;\n\n  constructor(value: T | undefined, config: ServerConnectionConfig) {\n    super(\n      value,\n      () => this.#connect(),\n      () => this.#disconnect(),\n    );\n    this.server = new ServerConnection(this.id, config);\n\n    this.subscribe((v) => {\n      if (!this.#paused) {\n        this.#pending.value = true;\n        this.#error.value = undefined;\n        this[$update](createSetStateEvent(v));\n      }\n    });\n\n    this.#paused = false;\n  }\n\n  /**\n   * Sets the local value of the signal without sending any events to the server\n   * @param value - The new value.\n   * @internal\n   */\n  protected setValueLocal(value: T): void {\n    this.#paused = true;\n    this.value = value;\n    this.#paused = false;\n  }\n\n  /**\n   * A method to update the server with the new value.\n   *\n   * @param event - The event to update the server with.\n   */\n  protected [$update](event: StateEvent<T>): void {\n    this.server\n      .update(event)\n      .catch((error: unknown) => {\n        this.#error.value = error instanceof Error ? error : new Error(String(error));\n      })\n      .finally(() => {\n        this.#pending.value = false;\n      });\n  }\n\n  /**\n   * A method with to process the server response. The implementation is\n   * specific for each signal type.\n   *\n   * @param event - The server response event.\n   */\n  protected abstract [$processServerResponse](event: StateEvent<T>): void;\n\n  #connect() {\n    this.server.connect().onNext((event: StateEvent<T>) => {\n      this.#paused = true;\n      this[$processServerResponse](event);\n      this.#paused = false;\n    });\n  }\n\n  #disconnect() {\n    if (this.server.subscription === undefined) {\n      return;\n    }\n    this.server.disconnect();\n  }\n}\n"],
+  "mappings": "AACA,SAAS,cAAc;AACvB,SAAS,UAAU,QAAQ,cAAc;AACzC,SAAS,2BAA4C;AAErD,MAAM,WAAW;AAQV,MAAe,iCAAoC,OAAU;AAAA,EACzD;AAAA,EACA;AAAA;AAAA;AAAA,EAIT,kBAAkB;AAAA,EAER,YAAY,OAAsB,kBAA8B,mBAA+B;AACvG,UAAM,KAAK;AACX,SAAK,oBAAoB;AACzB,SAAK,qBAAqB;AAAA,EAC5B;AAAA,EAEmB,EAAE,MAAqB;AACxC,UAAM,EAAE,IAAI;AACZ,QAAI,KAAK,oBAAoB,GAAG;AAC9B,WAAK,kBAAkB;AAAA,IACzB;AACA,SAAK,mBAAmB;AAAA,EAC1B;AAAA,EAEmB,EAAE,MAAqB;AACxC,UAAM,EAAE,IAAI;AACZ,SAAK,mBAAmB;AACxB,QAAI,KAAK,oBAAoB,GAAG;AAC9B,WAAK,mBAAmB;AAAA,IAC1B;AAAA,EACF;AACF;AAgCA,MAAM,iBAAoB;AAAA,EACf;AAAA,EACA;AAAA,EACT;AAAA,EAEA,YAAY,IAAY,QAAgC;AACtD,SAAK,UAAU;AACf,SAAK,MAAM;AAAA,EACb;AAAA,EAEA,IAAI,eAAe;AACjB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,UAAU;AACR,UAAM,EAAE,QAAQ,UAAU,QAAQ,OAAO,IAAI,KAAK;AAElD,SAAK,kBAAkB,OAAO,UAAU,UAAU,aAAa;AAAA,MAC7D,kBAAkB;AAAA,MAClB,gBAAgB;AAAA,MAChB,gBAAgB,KAAK;AAAA,MACrB;AAAA,IACF,CAAC;AAED,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,MAAM,OAAO,OAAqC;AAChD,UAAM,KAAK,QAAQ,OAAO,KAAK,UAAU,UAAU;AAAA,MACjD,gBAAgB,KAAK;AAAA,MACrB;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,aAAa;AACX,SAAK,eAAe,OAAO;AAC3B,SAAK,gBAAgB;AAAA,EACvB;AACF;AAEO,MAAM,UAAU,OAAO,QAAQ;AAC/B,MAAM,yBAAyB,OAAO,uBAAuB;AAU7D,MAAe,wBAA2B,yBAA4B;AAAA;AAAA;AAAA;AAAA;AAAA,EAKlE,KAAK,OAAO;AAAA;AAAA;AAAA;AAAA,EAKZ;AAAA;AAAA;AAAA;AAAA,EAKA,UAAU,SAAS,MAAM,KAAK,SAAS,KAAK;AAAA;AAAA;AAAA;AAAA,EAK5C,QAAQ,SAAS,MAAM,KAAK,OAAO,KAAK;AAAA,EAExC,WAAW,OAAO,KAAK;AAAA,EACvB,SAAS,OAA0B,MAAS;AAAA;AAAA;AAAA,EAIrD,UAAU;AAAA,EAEV,YAAY,OAAsB,QAAgC;AAChE;AAAA,MACE;AAAA,MACA,MAAM,KAAK,SAAS;AAAA,MACpB,MAAM,KAAK,YAAY;AAAA,IACzB;AACA,SAAK,SAAS,IAAI,iBAAiB,KAAK,IAAI,MAAM;AAElD,SAAK,UAAU,CAAC,MAAM;AACpB,UAAI,CAAC,KAAK,SAAS;AACjB,aAAK,SAAS,QAAQ;AACtB,aAAK,OAAO,QAAQ;AACpB,aAAK,OAAO,EAAE,oBAAoB,CAAC,CAAC;AAAA,MACtC;AAAA,IACF,CAAC;AAED,SAAK,UAAU;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOU,cAAc,OAAgB;AACtC,SAAK,UAAU;AACf,SAAK,QAAQ;AACb,SAAK,UAAU;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,CAAW,OAAO,EAAE,OAA4B;AAC9C,SAAK,OACF,OAAO,KAAK,EACZ,MAAM,CAAC,UAAmB;AACzB,WAAK,OAAO,QAAQ,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;AAAA,IAC9E,CAAC,EACA,QAAQ,MAAM;AACb,WAAK,SAAS,QAAQ;AAAA,IACxB,CAAC;AAAA,EACL;AAAA,EAUA,WAAW;AACT,SAAK,OAAO,QAAQ,EAAE,OAAO,CAAC,UAAyB;AACrD,WAAK,UAAU;AACf,WAAK,sBAAsB,EAAE,KAAK;AAClC,WAAK,UAAU;AAAA,IACjB,CAAC;AAAA,EACH;AAAA,EAEA,cAAc;AACZ,QAAI,KAAK,OAAO,iBAAiB,QAAW;AAC1C;AAAA,IACF;AACA,SAAK,OAAO,WAAW;AAAA,EACzB;AACF;",
+  "names": []
+}

package/NumberSignal.d.ts

@@ -0,0 +1,40 @@
+import { ValueSignal } from './ValueSignal.js';
+/**
+ * A signal that holds a number value. The underlying
+ * value of this signal is stored and updated as a
+ * shared value on the server.
+ *
+ * After obtaining the NumberSignal instance from
+ * a server-side service that returns one, the value
+ * can be updated using the `value` property,
+ * and it can be read with or without the
+ * `value` property (similar to a normal signal):
+ *
+ * @example
+ * ```tsx
+ *  const counter = CounterService.counter();
+ *
+ * return (
+ *    <Button onClick={() => counter.incrementBy(1)}>
+ *      Click count: { counter }
+ *    </Button>
+ *    <Button onClick={() => counter.value = 0}>Reset</Button>
+ * );
+ * ```
+ */
+export declare class NumberSignal extends ValueSignal<number> {
+    /**
+     * Increments the value by the specified delta. The delta can be negative to
+     * decrease the value.
+     *
+     * This method differs from using the `++` or `+=` operators directly on the
+     * signal value. It performs an atomic operation to prevent conflicts from
+     * concurrent changes, ensuring that other users' modifications are not
+     * accidentally overwritten.
+     *
+     * @param delta - The delta to increment the value by. The delta can be
+     * negative.
+     */
+    incrementBy(delta: number): void;
+}
+//# sourceMappingURL=NumberSignal.d.ts.map

package/NumberSignal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NumberSignal.d.ts","sourceRoot":"","sources":["src/NumberSignal.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,YAAa,SAAQ,WAAW,CAAC,MAAM,CAAC;IACnD;;;;;;;;;;;OAWG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAQjC"}

package/NumberSignal.js

@@ -0,0 +1,29 @@
+import { createIncrementStateEvent } from "./events.js";
+import { $update } from "./FullStackSignal.js";
+import { ValueSignal } from "./ValueSignal.js";
+class NumberSignal extends ValueSignal {
+  /**
+   * Increments the value by the specified delta. The delta can be negative to
+   * decrease the value.
+   *
+   * This method differs from using the `++` or `+=` operators directly on the
+   * signal value. It performs an atomic operation to prevent conflicts from
+   * concurrent changes, ensuring that other users' modifications are not
+   * accidentally overwritten.
+   *
+   * @param delta - The delta to increment the value by. The delta can be
+   * negative.
+   */
+  incrementBy(delta) {
+    if (delta === 0) {
+      return;
+    }
+    this.setValueLocal(this.value + delta);
+    const event = createIncrementStateEvent(delta);
+    this[$update](event);
+  }
+}
+export {
+  NumberSignal
+};
+//# sourceMappingURL=NumberSignal.js.map

package/NumberSignal.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/NumberSignal.ts"],
+  "sourcesContent": ["import { createIncrementStateEvent } from './events.js';\nimport { $update } from './FullStackSignal.js';\nimport { ValueSignal } from './ValueSignal.js';\n\n/**\n * A signal that holds a number value. The underlying\n * value of this signal is stored and updated as a\n * shared value on the server.\n *\n * After obtaining the NumberSignal instance from\n * a server-side service that returns one, the value\n * can be updated using the `value` property,\n * and it can be read with or without the\n * `value` property (similar to a normal signal):\n *\n * @example\n * ```tsx\n *  const counter = CounterService.counter();\n *\n * return (\n *    <Button onClick={() => counter.incrementBy(1)}>\n *      Click count: { counter }\n *    </Button>\n *    <Button onClick={() => counter.value = 0}>Reset</Button>\n * );\n * ```\n */\nexport class NumberSignal extends ValueSignal<number> {\n  /**\n   * Increments the value by the specified delta. The delta can be negative to\n   * decrease the value.\n   *\n   * This method differs from using the `++` or `+=` operators directly on the\n   * signal value. It performs an atomic operation to prevent conflicts from\n   * concurrent changes, ensuring that other users' modifications are not\n   * accidentally overwritten.\n   *\n   * @param delta - The delta to increment the value by. The delta can be\n   * negative.\n   */\n  incrementBy(delta: number): void {\n    if (delta === 0) {\n      return;\n    }\n    this.setValueLocal(this.value + delta);\n    const event = createIncrementStateEvent(delta);\n    this[$update](event);\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,iCAAiC;AAC1C,SAAS,eAAe;AACxB,SAAS,mBAAmB;AAyBrB,MAAM,qBAAqB,YAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAapD,YAAY,OAAqB;AAC/B,QAAI,UAAU,GAAG;AACf;AAAA,IACF;AACA,SAAK,cAAc,KAAK,QAAQ,KAAK;AACrC,UAAM,QAAQ,0BAA0B,KAAK;AAC7C,SAAK,OAAO,EAAE,KAAK;AAAA,EACrB;AACF;",
+  "names": []
+}

package/ValueSignal.d.ts

@@ -0,0 +1,49 @@
+import { type StateEvent } from './events.js';
+import { $processServerResponse, FullStackSignal } from './FullStackSignal.js';
+/**
+ * An operation subscription that can be canceled.
+ */
+export interface OperationSubscription {
+    cancel(): void;
+}
+/**
+ * A full-stack signal that holds an arbitrary value.
+ */
+export declare class ValueSignal<T> extends FullStackSignal<T> {
+    #private;
+    /**
+     * Sets the value.
+     * Note that the value change event that is propagated to the server as the
+     * result of this operation is not taking the last seen value into account and
+     * will overwrite the shared value on the server unconditionally (AKA: "Last
+     * Write Wins"). If you need to perform a conditional update, use the
+     * `replace` method instead.
+     *
+     * @param value - The new value.
+     */
+    set(value: T): void;
+    /**
+     * Replaces the value with a new one only if the current value is equal to the
+     * expected value.
+     *
+     * @param expected - The expected value.
+     * @param newValue - The new value.
+     */
+    replace(expected: T, newValue: T): void;
+    /**
+     * Tries to update the value by applying the callback function to the current
+     * value. In case of a concurrent change, the callback is run again with an
+     * updated input value. This is repeated until the result can be applied
+     * without concurrent changes, or the operation is canceled.
+     *
+     * Note that there is no guarantee that cancel() will be effective always,
+     * since a succeeding operation might already be on its way to the server.
+     *
+     * @param callback - The function that is applied on the current value to
+     *                   produce the new value.
+     * @returns An operation subscription that can be canceled.
+     */
+    update(callback: (value: T) => T): OperationSubscription;
+    protected [$processServerResponse](event: StateEvent<T>): void;
+}
+//# sourceMappingURL=ValueSignal.d.ts.map

package/ValueSignal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValueSignal.d.ts","sourceRoot":"","sources":["src/ValueSignal.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACvE,OAAO,EAAE,sBAAsB,EAAW,eAAe,EAAE,MAAM,sBAAsB,CAAC;AASxF;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,MAAM,IAAI,IAAI,CAAC;CAChB;AAED;;GAEG;AACH,qBAAa,WAAW,CAAC,CAAC,CAAE,SAAQ,eAAe,CAAC,CAAC,CAAC;;IAGpD;;;;;;;;;OASG;IACH,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAInB;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI;IAIvC;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,qBAAqB;cAerC,CAAC,sBAAsB,CAAC,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI;CAoBxE"}

package/ValueSignal.js

@@ -0,0 +1,76 @@
+import { createReplaceStateEvent } from "./events.js";
+import { $processServerResponse, $update, FullStackSignal } from "./FullStackSignal.js";
+class ValueSignal extends FullStackSignal {
+  #pendingRequests = /* @__PURE__ */ new Map();
+  /**
+   * Sets the value.
+   * Note that the value change event that is propagated to the server as the
+   * result of this operation is not taking the last seen value into account and
+   * will overwrite the shared value on the server unconditionally (AKA: "Last
+   * Write Wins"). If you need to perform a conditional update, use the
+   * `replace` method instead.
+   *
+   * @param value - The new value.
+   */
+  set(value) {
+    this.value = value;
+  }
+  /**
+   * Replaces the value with a new one only if the current value is equal to the
+   * expected value.
+   *
+   * @param expected - The expected value.
+   * @param newValue - The new value.
+   */
+  replace(expected, newValue) {
+    this[$update](createReplaceStateEvent(expected, newValue));
+  }
+  /**
+   * Tries to update the value by applying the callback function to the current
+   * value. In case of a concurrent change, the callback is run again with an
+   * updated input value. This is repeated until the result can be applied
+   * without concurrent changes, or the operation is canceled.
+   *
+   * Note that there is no guarantee that cancel() will be effective always,
+   * since a succeeding operation might already be on its way to the server.
+   *
+   * @param callback - The function that is applied on the current value to
+   *                   produce the new value.
+   * @returns An operation subscription that can be canceled.
+   */
+  update(callback) {
+    const newValue = callback(this.value);
+    const event = createReplaceStateEvent(this.value, newValue);
+    this[$update](event);
+    const waiter = Promise.withResolvers();
+    const pendingRequest = { callback, waiter, canceled: false };
+    this.#pendingRequests.set(event.id, pendingRequest);
+    return {
+      cancel: () => {
+        pendingRequest.canceled = true;
+        pendingRequest.waiter.resolve();
+      }
+    };
+  }
+  [$processServerResponse](event) {
+    const record = this.#pendingRequests.get(event.id);
+    if (record) {
+      this.#pendingRequests.delete(event.id);
+    }
+    if (event.type === "snapshot") {
+      if (record) {
+        record.waiter.resolve();
+      }
+      this.value = event.value;
+    }
+    if (event.type === "reject" && record) {
+      if (!record.canceled) {
+        this.update(record.callback);
+      }
+    }
+  }
+}
+export {
+  ValueSignal
+};
+//# sourceMappingURL=ValueSignal.js.map

package/ValueSignal.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/ValueSignal.ts"],
+  "sourcesContent": ["import { createReplaceStateEvent, type StateEvent } from './events.js';\nimport { $processServerResponse, $update, FullStackSignal } from './FullStackSignal.js';\n\ntype PromiseWithResolvers = ReturnType<typeof Promise.withResolvers<void>>;\ntype PendingRequestsRecord<T> = Readonly<{\n  waiter: PromiseWithResolvers;\n  callback(value: T): T;\n  canceled: boolean;\n}>;\n\n/**\n * An operation subscription that can be canceled.\n */\nexport interface OperationSubscription {\n  cancel(): void;\n}\n\n/**\n * A full-stack signal that holds an arbitrary value.\n */\nexport class ValueSignal<T> extends FullStackSignal<T> {\n  readonly #pendingRequests = new Map<string, PendingRequestsRecord<T>>();\n\n  /**\n   * Sets the value.\n   * Note that the value change event that is propagated to the server as the\n   * result of this operation is not taking the last seen value into account and\n   * will overwrite the shared value on the server unconditionally (AKA: \"Last\n   * Write Wins\"). If you need to perform a conditional update, use the\n   * `replace` method instead.\n   *\n   * @param value - The new value.\n   */\n  set(value: T): void {\n    this.value = value;\n  }\n\n  /**\n   * Replaces the value with a new one only if the current value is equal to the\n   * expected value.\n   *\n   * @param expected - The expected value.\n   * @param newValue - The new value.\n   */\n  replace(expected: T, newValue: T): void {\n    this[$update](createReplaceStateEvent(expected, newValue));\n  }\n\n  /**\n   * Tries to update the value by applying the callback function to the current\n   * value. In case of a concurrent change, the callback is run again with an\n   * updated input value. This is repeated until the result can be applied\n   * without concurrent changes, or the operation is canceled.\n   *\n   * Note that there is no guarantee that cancel() will be effective always,\n   * since a succeeding operation might already be on its way to the server.\n   *\n   * @param callback - The function that is applied on the current value to\n   *                   produce the new value.\n   * @returns An operation subscription that can be canceled.\n   */\n  update(callback: (value: T) => T): OperationSubscription {\n    const newValue = callback(this.value);\n    const event = createReplaceStateEvent(this.value, newValue);\n    this[$update](event);\n    const waiter = Promise.withResolvers<void>();\n    const pendingRequest = { callback, waiter, canceled: false };\n    this.#pendingRequests.set(event.id, pendingRequest);\n    return {\n      cancel: () => {\n        pendingRequest.canceled = true;\n        pendingRequest.waiter.resolve();\n      },\n    };\n  }\n\n  protected override [$processServerResponse](event: StateEvent<T>): void {\n    const record = this.#pendingRequests.get(event.id);\n    if (record) {\n      this.#pendingRequests.delete(event.id);\n    }\n\n    if (event.type === 'snapshot') {\n      if (record) {\n        record.waiter.resolve();\n      }\n      this.value = event.value;\n    }\n\n    if (event.type === 'reject' && record) {\n      if (!record.canceled) {\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        this.update(record.callback);\n      }\n    }\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,+BAAgD;AACzD,SAAS,wBAAwB,SAAS,uBAAuB;AAmB1D,MAAM,oBAAuB,gBAAmB;AAAA,EAC5C,mBAAmB,oBAAI,IAAsC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYtE,IAAI,OAAgB;AAClB,SAAK,QAAQ;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,QAAQ,UAAa,UAAmB;AACtC,SAAK,OAAO,EAAE,wBAAwB,UAAU,QAAQ,CAAC;AAAA,EAC3D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeA,OAAO,UAAkD;AACvD,UAAM,WAAW,SAAS,KAAK,KAAK;AACpC,UAAM,QAAQ,wBAAwB,KAAK,OAAO,QAAQ;AAC1D,SAAK,OAAO,EAAE,KAAK;AACnB,UAAM,SAAS,QAAQ,cAAoB;AAC3C,UAAM,iBAAiB,EAAE,UAAU,QAAQ,UAAU,MAAM;AAC3D,SAAK,iBAAiB,IAAI,MAAM,IAAI,cAAc;AAClD,WAAO;AAAA,MACL,QAAQ,MAAM;AACZ,uBAAe,WAAW;AAC1B,uBAAe,OAAO,QAAQ;AAAA,MAChC;AAAA,IACF;AAAA,EACF;AAAA,EAEA,CAAoB,sBAAsB,EAAE,OAA4B;AACtE,UAAM,SAAS,KAAK,iBAAiB,IAAI,MAAM,EAAE;AACjD,QAAI,QAAQ;AACV,WAAK,iBAAiB,OAAO,MAAM,EAAE;AAAA,IACvC;AAEA,QAAI,MAAM,SAAS,YAAY;AAC7B,UAAI,QAAQ;AACV,eAAO,OAAO,QAAQ;AAAA,MACxB;AACA,WAAK,QAAQ,MAAM;AAAA,IACrB;AAEA,QAAI,MAAM,SAAS,YAAY,QAAQ;AACrC,UAAI,CAAC,OAAO,UAAU;AAEpB,aAAK,OAAO,OAAO,QAAQ;AAAA,MAC7B;AAAA,IACF;AAAA,EACF;AACF;",
+  "names": []
+}

package/events.d.ts

@@ -0,0 +1,33 @@
+import type { Simplify } from 'type-fest';
+/**
+ * Creates a new state event type.
+ */
+type CreateStateEventType<V, T extends string, C extends Record<string, unknown> = Record<never, never>> = Simplify<Readonly<{
+    id: string;
+    type: T;
+    value: V;
+}> & Readonly<C>>;
+/**
+ * A state event received from the server describing the current state of the
+ * signal.
+ */
+export type SnapshotStateEvent<T> = CreateStateEventType<T, 'snapshot'>;
+export type RejectStateEvent = CreateStateEventType<never, 'reject'>;
+/**
+ * A state event defines a new value of the signal shared with the server. The
+ *
+ */
+export type SetStateEvent<T> = CreateStateEventType<T, 'set'>;
+export declare function createSetStateEvent<T>(value: T): SetStateEvent<T>;
+export type ReplaceStateEvent<T> = CreateStateEventType<T, 'replace', {
+    expected: T;
+}>;
+export declare function createReplaceStateEvent<T>(expected: T, value: T): ReplaceStateEvent<T>;
+export type IncrementStateEvent = CreateStateEventType<number, 'increment'>;
+export declare function createIncrementStateEvent(delta: number): IncrementStateEvent;
+/**
+ * An object that describes the change of the signal state.
+ */
+export type StateEvent<T> = IncrementStateEvent | RejectStateEvent | ReplaceStateEvent<T> | SetStateEvent<T> | SnapshotStateEvent<T>;
+export {};
+//# sourceMappingURL=events.d.ts.map

package/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["src/events.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAE1C;;GAEG;AACH,KAAK,oBAAoB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,QAAQ,CACjH,QAAQ,CAAC;IACP,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,CAAC,CAAC;IACR,KAAK,EAAE,CAAC,CAAC;CACV,CAAC,GACA,QAAQ,CAAC,CAAC,CAAC,CACd,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI,oBAAoB,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;AAExE,MAAM,MAAM,gBAAgB,GAAG,oBAAoB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;AAErE;;;GAGG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,oBAAoB,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AAE9D,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAMjE;AAED,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,oBAAoB,CAAC,CAAC,EAAE,SAAS,EAAE;IAAE,QAAQ,EAAE,CAAC,CAAA;CAAE,CAAC,CAAC;AAEvF,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAOtF;AAED,MAAM,MAAM,mBAAmB,GAAG,oBAAoB,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;AAE5E,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,mBAAmB,CAM5E;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IACpB,mBAAmB,GACnB,gBAAgB,GAChB,iBAAiB,CAAC,CAAC,CAAC,GACpB,aAAa,CAAC,CAAC,CAAC,GAChB,kBAAkB,CAAC,CAAC,CAAC,CAAC"}

package/events.js

@@ -0,0 +1,29 @@
+import { nanoid } from "nanoid";
+function createSetStateEvent(value) {
+  return {
+    id: nanoid(),
+    type: "set",
+    value
+  };
+}
+function createReplaceStateEvent(expected, value) {
+  return {
+    id: nanoid(),
+    type: "replace",
+    value,
+    expected
+  };
+}
+function createIncrementStateEvent(delta) {
+  return {
+    id: nanoid(),
+    type: "increment",
+    value: delta
+  };
+}
+export {
+  createIncrementStateEvent,
+  createReplaceStateEvent,
+  createSetStateEvent
+};
+//# sourceMappingURL=events.js.map

package/events.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/events.ts"],
+  "sourcesContent": ["import { nanoid } from 'nanoid';\nimport type { Simplify } from 'type-fest';\n\n/**\n * Creates a new state event type.\n */\ntype CreateStateEventType<V, T extends string, C extends Record<string, unknown> = Record<never, never>> = Simplify<\n  Readonly<{\n    id: string;\n    type: T;\n    value: V;\n  }> &\n    Readonly<C>\n>;\n\n/**\n * A state event received from the server describing the current state of the\n * signal.\n */\nexport type SnapshotStateEvent<T> = CreateStateEventType<T, 'snapshot'>;\n\nexport type RejectStateEvent = CreateStateEventType<never, 'reject'>;\n\n/**\n * A state event defines a new value of the signal shared with the server. The\n *\n */\nexport type SetStateEvent<T> = CreateStateEventType<T, 'set'>;\n\nexport function createSetStateEvent<T>(value: T): SetStateEvent<T> {\n  return {\n    id: nanoid(),\n    type: 'set',\n    value,\n  };\n}\n\nexport type ReplaceStateEvent<T> = CreateStateEventType<T, 'replace', { expected: T }>;\n\nexport function createReplaceStateEvent<T>(expected: T, value: T): ReplaceStateEvent<T> {\n  return {\n    id: nanoid(),\n    type: 'replace',\n    value,\n    expected,\n  };\n}\n\nexport type IncrementStateEvent = CreateStateEventType<number, 'increment'>;\n\nexport function createIncrementStateEvent(delta: number): IncrementStateEvent {\n  return {\n    id: nanoid(),\n    type: 'increment',\n    value: delta,\n  };\n}\n\n/**\n * An object that describes the change of the signal state.\n */\nexport type StateEvent<T> =\n  | IncrementStateEvent\n  | RejectStateEvent\n  | ReplaceStateEvent<T>\n  | SetStateEvent<T>\n  | SnapshotStateEvent<T>;\n"],
+  "mappings": "AAAA,SAAS,cAAc;AA6BhB,SAAS,oBAAuB,OAA4B;AACjE,SAAO;AAAA,IACL,IAAI,OAAO;AAAA,IACX,MAAM;AAAA,IACN;AAAA,EACF;AACF;AAIO,SAAS,wBAA2B,UAAa,OAAgC;AACtF,SAAO;AAAA,IACL,IAAI,OAAO;AAAA,IACX,MAAM;AAAA,IACN;AAAA,IACA;AAAA,EACF;AACF;AAIO,SAAS,0BAA0B,OAAoC;AAC5E,SAAO;AAAA,IACL,IAAI,OAAO;AAAA,IACX,MAAM;AAAA,IACN,OAAO;AAAA,EACT;AACF;",
+  "names": []
+}

package/index.d.ts

@@ -1,5 +1,7 @@
+import './polyfills.js';
 export * from './core.js';
-export { NumberSignalChannel } from './EventChannel.js';
-export { NumberSignal, ValueSignal } from './Signals.js';
-export * from './types.js';
+export { NumberSignal } from './NumberSignal.js';
+export { ValueSignal } from './ValueSignal.js';
+export type { OperationSubscription } from './ValueSignal.js';
+export { FullStackSignal } from './FullStackSignal.js';
 //# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AACA,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AACzD,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AACA,OAAO,gBAAgB,CAAC;AAGxB,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,YAAY,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC"}

package/index.js

@@ -1,10 +1,11 @@
+import "./polyfills.js";
 export * from "./core.js";
-import { NumberSignalChannel } from "./EventChannel.js";
-import { NumberSignal, ValueSignal } from "./Signals.js";
-export * from "./types.js";
+import { NumberSignal } from "./NumberSignal.js";
+import { ValueSignal } from "./ValueSignal.js";
+import { FullStackSignal } from "./FullStackSignal.js";
 export {
+  FullStackSignal,
   NumberSignal,
-  NumberSignalChannel,
   ValueSignal
 };
 //# sourceMappingURL=index.js.map

package/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["src/index.ts"],
-  "sourcesContent": ["// eslint-disable-next-line import/export\nexport * from './core.js';\nexport { NumberSignalChannel } from './EventChannel.js';\nexport { NumberSignal, ValueSignal } from './Signals.js';\nexport * from './types.js';\n"],
-  "mappings": "AACA,cAAc;AACd,SAAS,2BAA2B;AACpC,SAAS,cAAc,mBAAmB;AAC1C,cAAc;",
+  "sourcesContent": ["// eslint-disable-next-line import/no-unassigned-import\nimport './polyfills.js';\n\n// eslint-disable-next-line import/export\nexport * from './core.js';\nexport { NumberSignal } from './NumberSignal.js';\nexport { ValueSignal } from './ValueSignal.js';\nexport type { OperationSubscription } from './ValueSignal.js';\nexport { FullStackSignal } from './FullStackSignal.js';\n"],
+  "mappings": "AACA,OAAO;AAGP,cAAc;AACd,SAAS,oBAAoB;AAC7B,SAAS,mBAAmB;AAE5B,SAAS,uBAAuB;",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vaadin/hilla-react-signals",
-  "version": "24.5.0-alpha8",
+  "version": "24.5.0-beta1",
   "description": "Signals for Hilla React",
   "main": "index.js",
   "module": "index.js",
@@ -47,12 +47,12 @@
   },
   "dependencies": {
     "@preact/signals-react": "^2.0.0",
-    "@vaadin/hilla-frontend": "24.5.0-alpha8",
+    "@vaadin/hilla-frontend": "24.5.0-beta1",
     "nanoid": "^5.0.7"
   },
   "peerDependencies": {
     "react": "^18",
-    "react-router-dom": "^6"
+    "react-router-dom": "^6.26.2"
   },
   "devDependencies": {
     "@esm-bundle/chai": "^4.3.4-fix.0",
@@ -74,6 +74,6 @@
     "karma-viewport": "^1.0.9",
     "sinon": "^16.0.0",
     "sinon-chai": "^3.7.0",
-    "typescript": "5.5.2"
+    "typescript": "5.6.2"
   }
 }

package/polyfills.d.ts

@@ -0,0 +1,11 @@
+declare global {
+    interface PromiseConstructor {
+        withResolvers<T>(): {
+            resolve(value: T): void;
+            reject(reason?: unknown): void;
+            promise: Promise<T>;
+        };
+    }
+}
+export {};
+//# sourceMappingURL=polyfills.d.ts.map

package/polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polyfills.d.ts","sourceRoot":"","sources":["src/polyfills.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,kBAAkB;QAC1B,aAAa,CAAC,CAAC,KAAK;YAClB,OAAO,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;YACxB,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;YAC/B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;SACrB,CAAC;KACH;CACF;AAkBD,OAAO,EAAE,CAAC"}

package/polyfills.js

@@ -0,0 +1,15 @@
+if (!("withResolvers" in Promise)) {
+  Object.defineProperty(Promise, "withResolvers", {
+    configurable: true,
+    value() {
+      let resolve;
+      let reject;
+      const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+      });
+      return { resolve, reject, promise };
+    }
+  });
+}
+//# sourceMappingURL=polyfills.js.map

package/polyfills.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/polyfills.ts"],
+  "sourcesContent": ["// TODO: Remove this polyfill when we move to ECMA2024\ndeclare global {\n  interface PromiseConstructor {\n    withResolvers<T>(): {\n      resolve(value: T): void;\n      reject(reason?: unknown): void;\n      promise: Promise<T>;\n    };\n  }\n}\n\nif (!('withResolvers' in Promise)) {\n  // eslint-disable-next-line no-extend-native\n  Object.defineProperty(Promise, 'withResolvers', {\n    configurable: true,\n    value<T>() {\n      let resolve: (value: T) => void;\n      let reject: (reason?: unknown) => void;\n      const promise = new Promise<T>((_resolve, _reject) => {\n        resolve = _resolve;\n        reject = _reject;\n      });\n      return { resolve: resolve!, reject: reject!, promise };\n    },\n  });\n}\n\nexport {};\n"],
+  "mappings": "AAWA,IAAI,EAAE,mBAAmB,UAAU;AAEjC,SAAO,eAAe,SAAS,iBAAiB;AAAA,IAC9C,cAAc;AAAA,IACd,QAAW;AACT,UAAI;AACJ,UAAI;AACJ,YAAM,UAAU,IAAI,QAAW,CAAC,UAAU,YAAY;AACpD,kBAAU;AACV,iBAAS;AAAA,MACX,CAAC;AACD,aAAO,EAAE,SAAmB,QAAiB,QAAQ;AAAA,IACvD;AAAA,EACF,CAAC;AACH;",
+  "names": []
+}

package/types.d.ts

@@ -1,16 +1,10 @@
-/**
- * Types of events that can be produced or processed by a signal.
- */
-export declare enum StateEventType {
-    SET = "set",
-    SNAPSHOT = "snapshot"
+import { Signal as _Signal } from '@preact/signals-react';
+
+declare module './core.js' {
+  export declare class Signal<T> extends _Signal<T> {
+    protected S(node: unknown): void;
+    protected U(node: unknown): void;
+  }
 }
-/**
- * Event that describes the state of a signal.
- */
-export type StateEvent = {
-    id: string;
-    type: StateEventType;
-    value: any;
-};
-//# sourceMappingURL=types.d.ts.map
+
+export {};

package/utils.d.ts

@@ -0,0 +1,3 @@
+import type { ReadonlySignal } from '@preact/signals-react';
+export declare function createPromiseFromSignal<T, U, E>(signal: ReadonlySignal<T>, callback: (value: T, resolve: (value: PromiseLike<U> | U) => void, reject: (reason?: E) => void) => void): Promise<U>;
+//# sourceMappingURL=utils.d.ts.map

package/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,wBAAsB,uBAAuB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACnD,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,EACzB,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,IAAI,KAAK,IAAI,GACvG,OAAO,CAAC,CAAC,CAAC,CAWZ"}

package/utils.js

@@ -0,0 +1,15 @@
+async function createPromiseFromSignal(signal, callback) {
+  return new Promise((resolve, reject) => {
+    const unsubscribe = signal.subscribe((value) => {
+      if (!value) {
+        return;
+      }
+      unsubscribe();
+      callback(value, resolve, reject);
+    });
+  });
+}
+export {
+  createPromiseFromSignal
+};
+//# sourceMappingURL=utils.js.map

package/utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/utils.ts"],
+  "sourcesContent": ["import type { ReadonlySignal } from '@preact/signals-react';\n\nexport async function createPromiseFromSignal<T, U, E>(\n  signal: ReadonlySignal<T>,\n  callback: (value: T, resolve: (value: PromiseLike<U> | U) => void, reject: (reason?: E) => void) => void,\n): Promise<U> {\n  return new Promise((resolve, reject) => {\n    const unsubscribe = signal.subscribe((value) => {\n      if (!value) {\n        return;\n      }\n\n      unsubscribe();\n      callback(value, resolve, reject);\n    });\n  });\n}\n"],
+  "mappings": "AAEA,eAAsB,wBACpB,QACA,UACY;AACZ,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,UAAM,cAAc,OAAO,UAAU,CAAC,UAAU;AAC9C,UAAI,CAAC,OAAO;AACV;AAAA,MACF;AAEA,kBAAY;AACZ,eAAS,OAAO,SAAS,MAAM;AAAA,IACjC,CAAC;AAAA,EACH,CAAC;AACH;",
+  "names": []
+}

package/EventChannel.d.ts

@@ -1,38 +0,0 @@
-import type { ConnectClient } from '@vaadin/hilla-frontend';
-import { NumberSignal, type ValueSignal } from './Signals.js';
-import { type StateEvent } from './types.js';
-/**
- * A generic class that represents a signal channel
- * that can be used to communicate with a server-side
- * signal instance.
- *
- * The signal channel is responsible for subscribing to
- * the server-side signal and updating the local signal
- * based on the received events.
- *
- * @typeParam T - The type of the signal value.
- * @typeParam S - The type of the signal instance.
- */
-declare abstract class SignalChannel<T, S extends ValueSignal<T>> {
-    #private;
-    constructor(signalProviderServiceMethod: string, connectClient: ConnectClient);
-    publish(event: StateEvent): Promise<boolean>;
-    /**
-     * Returns the signal instance to be used in components.
-     */
-    get signal(): S;
-    /**
-     * Returns the id of the signal channel.
-     */
-    get id(): string;
-    abstract createInternalSignal(publish: (event: StateEvent) => Promise<boolean>, initialValue?: T): S;
-}
-/**
- * A signal channel that is used to communicate with a
- * server-side signal instance that holds a number value.
- */
-export declare class NumberSignalChannel extends SignalChannel<number, NumberSignal> {
-    createInternalSignal(publish: (event: StateEvent) => Promise<boolean>, initialValue?: number): NumberSignal;
-}
-export {};
-//# sourceMappingURL=EventChannel.d.ts.map

package/EventChannel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"EventChannel.d.ts","sourceRoot":"","sources":["src/EventChannel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,wBAAwB,CAAC;AAE1E,OAAO,EAAE,YAAY,EAAoB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhF,OAAO,EAAE,KAAK,UAAU,EAAkB,MAAM,YAAY,CAAC;AAY7D;;;;;;;;;;;GAWG;AACH,uBAAe,aAAa,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,CAAC,CAAC,CAAC;;gBAO1C,2BAA2B,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa;IA8BvE,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC;IAKlD;;OAEG;IACH,IAAI,MAAM,IAAI,CAAC,CAEd;IAED;;OAEG;IACH,IAAI,EAAE,IAAI,MAAM,CAEf;IAED,QAAQ,CAAC,oBAAoB,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,CAAC;CACrG;AAED;;;GAGG;AACH,qBAAa,mBAAoB,SAAQ,aAAa,CAAC,MAAM,EAAE,YAAY,CAAC;IACjE,oBAAoB,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,YAAY;CAGrH"}

package/EventChannel.js

@@ -1,56 +0,0 @@
-import { nanoid } from "nanoid";
-import { NumberSignal, setInternalValue } from "./Signals.js";
-import SignalsHandler from "./SignalsHandler";
-import { StateEventType } from "./types.js";
-class SignalChannel {
-  #channelDescriptor;
-  #signalsHandler;
-  #id;
-  #internalSignal;
-  constructor(signalProviderServiceMethod, connectClient) {
-    this.#id = nanoid();
-    this.#signalsHandler = new SignalsHandler(connectClient);
-    this.#channelDescriptor = {
-      signalProviderEndpointMethod: signalProviderServiceMethod,
-      subscribe: (signalProviderEndpointMethod, signalId) => this.#signalsHandler.subscribe(signalProviderEndpointMethod, signalId),
-      publish: async (signalId, event) => this.#signalsHandler.update(signalId, event)
-    };
-    this.#internalSignal = this.createInternalSignal(async (event) => this.publish(event));
-    this.#connect();
-  }
-  #connect() {
-    this.#channelDescriptor.subscribe(this.#channelDescriptor.signalProviderEndpointMethod, this.#id).onNext((stateEvent) => {
-      this.#updateSignals(stateEvent);
-    });
-  }
-  #updateSignals(stateEvent) {
-    if (stateEvent.type === StateEventType.SNAPSHOT) {
-      setInternalValue(this.#internalSignal, stateEvent.value);
-    }
-  }
-  async publish(event) {
-    await this.#channelDescriptor.publish(this.#id, event);
-    return true;
-  }
-  /**
-   * Returns the signal instance to be used in components.
-   */
-  get signal() {
-    return this.#internalSignal;
-  }
-  /**
-   * Returns the id of the signal channel.
-   */
-  get id() {
-    return this.#id;
-  }
-}
-class NumberSignalChannel extends SignalChannel {
-  createInternalSignal(publish, initialValue) {
-    return new NumberSignal(publish, initialValue);
-  }
-}
-export {
-  NumberSignalChannel
-};
-//# sourceMappingURL=EventChannel.js.map

package/EventChannel.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["src/EventChannel.ts"],
-  "sourcesContent": ["import type { ConnectClient, Subscription } from '@vaadin/hilla-frontend';\nimport { nanoid } from 'nanoid';\nimport { NumberSignal, setInternalValue, type ValueSignal } from './Signals.js';\nimport SignalsHandler from './SignalsHandler';\nimport { type StateEvent, StateEventType } from './types.js';\n\n/**\n * The type that describes the needed information to\n * subscribe and publish to a server-side signal instance.\n */\ntype SignalChannelDescriptor<T> = Readonly<{\n  signalProviderEndpointMethod: string;\n  subscribe(signalProviderEndpointMethod: string, clientSignalId: string): Subscription<T>;\n  publish(clientSignalId: string, event: T): Promise<void>;\n}>;\n\n/**\n * A generic class that represents a signal channel\n * that can be used to communicate with a server-side\n * signal instance.\n *\n * The signal channel is responsible for subscribing to\n * the server-side signal and updating the local signal\n * based on the received events.\n *\n * @typeParam T - The type of the signal value.\n * @typeParam S - The type of the signal instance.\n */\nabstract class SignalChannel<T, S extends ValueSignal<T>> {\n  readonly #channelDescriptor: SignalChannelDescriptor<StateEvent>;\n  readonly #signalsHandler: SignalsHandler;\n  readonly #id: string;\n\n  readonly #internalSignal: S;\n\n  constructor(signalProviderServiceMethod: string, connectClient: ConnectClient) {\n    this.#id = nanoid();\n    this.#signalsHandler = new SignalsHandler(connectClient);\n    this.#channelDescriptor = {\n      signalProviderEndpointMethod: signalProviderServiceMethod,\n      subscribe: (signalProviderEndpointMethod: string, signalId: string) =>\n        this.#signalsHandler.subscribe(signalProviderEndpointMethod, signalId),\n      publish: async (signalId: string, event: StateEvent) => this.#signalsHandler.update(signalId, event),\n    };\n\n    this.#internalSignal = this.createInternalSignal(async (event: StateEvent) => this.publish(event));\n\n    this.#connect();\n  }\n\n  #connect() {\n    this.#channelDescriptor\n      .subscribe(this.#channelDescriptor.signalProviderEndpointMethod, this.#id)\n      .onNext((stateEvent) => {\n        // Update signals based on the new value from the event:\n        this.#updateSignals(stateEvent);\n      });\n  }\n\n  #updateSignals(stateEvent: StateEvent): void {\n    if (stateEvent.type === StateEventType.SNAPSHOT) {\n      setInternalValue(this.#internalSignal, stateEvent.value);\n    }\n  }\n\n  async publish(event: StateEvent): Promise<boolean> {\n    await this.#channelDescriptor.publish(this.#id, event);\n    return true;\n  }\n\n  /**\n   * Returns the signal instance to be used in components.\n   */\n  get signal(): S {\n    return this.#internalSignal;\n  }\n\n  /**\n   * Returns the id of the signal channel.\n   */\n  get id(): string {\n    return this.#id;\n  }\n\n  abstract createInternalSignal(publish: (event: StateEvent) => Promise<boolean>, initialValue?: T): S;\n}\n\n/**\n * A signal channel that is used to communicate with a\n * server-side signal instance that holds a number value.\n */\nexport class NumberSignalChannel extends SignalChannel<number, NumberSignal> {\n  override createInternalSignal(publish: (event: StateEvent) => Promise<boolean>, initialValue?: number): NumberSignal {\n    return new NumberSignal(publish, initialValue);\n  }\n}\n"],
-  "mappings": "AACA,SAAS,cAAc;AACvB,SAAS,cAAc,wBAA0C;AACjE,OAAO,oBAAoB;AAC3B,SAA0B,sBAAsB;AAwBhD,MAAe,cAA2C;AAAA,EAC/C;AAAA,EACA;AAAA,EACA;AAAA,EAEA;AAAA,EAET,YAAY,6BAAqC,eAA8B;AAC7E,SAAK,MAAM,OAAO;AAClB,SAAK,kBAAkB,IAAI,eAAe,aAAa;AACvD,SAAK,qBAAqB;AAAA,MACxB,8BAA8B;AAAA,MAC9B,WAAW,CAAC,8BAAsC,aAChD,KAAK,gBAAgB,UAAU,8BAA8B,QAAQ;AAAA,MACvE,SAAS,OAAO,UAAkB,UAAsB,KAAK,gBAAgB,OAAO,UAAU,KAAK;AAAA,IACrG;AAEA,SAAK,kBAAkB,KAAK,qBAAqB,OAAO,UAAsB,KAAK,QAAQ,KAAK,CAAC;AAEjG,SAAK,SAAS;AAAA,EAChB;AAAA,EAEA,WAAW;AACT,SAAK,mBACF,UAAU,KAAK,mBAAmB,8BAA8B,KAAK,GAAG,EACxE,OAAO,CAAC,eAAe;AAEtB,WAAK,eAAe,UAAU;AAAA,IAChC,CAAC;AAAA,EACL;AAAA,EAEA,eAAe,YAA8B;AAC3C,QAAI,WAAW,SAAS,eAAe,UAAU;AAC/C,uBAAiB,KAAK,iBAAiB,WAAW,KAAK;AAAA,IACzD;AAAA,EACF;AAAA,EAEA,MAAM,QAAQ,OAAqC;AACjD,UAAM,KAAK,mBAAmB,QAAQ,KAAK,KAAK,KAAK;AACrD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,SAAY;AACd,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,KAAa;AACf,WAAO,KAAK;AAAA,EACd;AAGF;AAMO,MAAM,4BAA4B,cAAoC;AAAA,EAClE,qBAAqB,SAAkD,cAAqC;AACnH,WAAO,IAAI,aAAa,SAAS,YAAY;AAAA,EAC/C;AACF;",
-  "names": []
-}

package/Signals.d.ts

@@ -1,60 +0,0 @@
-import { Signal } from './core.js';
-import { type StateEvent } from './types';
-export declare let setInternalValue: <T>(signal: ValueSignal<T>, value: T) => void;
-/**
- * A signal that holds a value. The underlying
- * value of this signal is stored and updated as a
- * shared value on the server.
- *
- * @internal
- */
-export declare abstract class ValueSignal<T> extends Signal<T> {
-    #private;
-    /**
-     * Creates a new ValueSignal instance.
-     * @param publish - The function that publishes the
-     * value of the signal to the server.
-     * @param value - The initial value of the signal
-     * @defaultValue undefined
-     */
-    constructor(publish: (event: StateEvent) => Promise<boolean>, value?: T);
-    /**
-     * Returns the value of the signal.
-     */
-    get value(): T;
-    /**
-     * Publishes the new value to the server.
-     * Note that this method is not setting
-     * the signal's value.
-     *
-     * @param value - The new value of the signal
-     * to be published to the server.
-     */
-    set value(value: T);
-}
-/**
- * A signal that holds a number value. The underlying
- * value of this signal is stored and updated as a
- * shared value on the server.
- *
- * After obtaining the NumberSignal instance from
- * a server-side service that returns one, the value
- * can be updated using the `value` property,
- * and it can be read with or without the
- * `value` property (similar to a normal signal):
- *
- * @example
- * ```tsx
- *  const counter = CounterService.counter();
- *
- * return (
- *    <Button onClick={() => counter++)}>
- *      Click count: { counter }
- *    </Button>
- *    <Button onClick={() => counter.value = 0}>Reset</Button>
- * );
- * ```
- */
-export declare class NumberSignal extends ValueSignal<number> {
-}
-//# sourceMappingURL=Signals.d.ts.map

package/Signals.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Signals.d.ts","sourceRoot":"","sources":["src/Signals.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,EAAE,KAAK,UAAU,EAAkB,MAAM,SAAS,CAAC;AAG1D,eAAO,IAAI,gBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;AAE3E;;;;;;GAMG;AACH,8BAAsB,WAAW,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;;IAOpD;;;;;;OAMG;gBACS,OAAO,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC;IAKvE;;OAEG;IACH,IAAa,KAAK,IAAI,CAAC,CAEtB;IAED;;;;;;;OAOG;IACH,IAAa,KAAK,CAAC,KAAK,EAAE,CAAC,EAQ1B;CAUF;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,YAAa,SAAQ,WAAW,CAAC,MAAM,CAAC;CAAG"}

package/Signals.js

@@ -1,58 +0,0 @@
-import { nanoid } from "nanoid";
-import { Signal } from "./core.js";
-import { StateEventType } from "./types";
-let setInternalValue;
-class ValueSignal extends Signal {
-  static {
-    setInternalValue = (signal, value) => signal.#setInternalValue(value);
-  }
-  #publish;
-  /**
-   * Creates a new ValueSignal instance.
-   * @param publish - The function that publishes the
-   * value of the signal to the server.
-   * @param value - The initial value of the signal
-   * @defaultValue undefined
-   */
-  constructor(publish, value) {
-    super(value);
-    this.#publish = publish;
-  }
-  /**
-   * Returns the value of the signal.
-   */
-  get value() {
-    return super.value;
-  }
-  /**
-   * Publishes the new value to the server.
-   * Note that this method is not setting
-   * the signal's value.
-   *
-   * @param value - The new value of the signal
-   * to be published to the server.
-   */
-  set value(value) {
-    const id = nanoid();
-    this.#setInternalValue(value);
-    this.#publish({ id, type: StateEventType.SET, value }).catch((error) => {
-      throw error;
-    });
-  }
-  /**
-   * Sets the value of the signal.
-   * @param value - The new value of the signal.
-   * @internal
-   */
-  #setInternalValue(value) {
-    super.value = value;
-  }
-}
-class NumberSignal extends ValueSignal {
-}
-export {
-  NumberSignal,
-  ValueSignal,
-  setInternalValue
-};
-//# sourceMappingURL=Signals.js.map

package/Signals.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["src/Signals.ts"],
-  "sourcesContent": ["import { nanoid } from 'nanoid';\nimport { Signal } from './core.js';\nimport { type StateEvent, StateEventType } from './types';\n\n// eslint-disable-next-line import/no-mutable-exports\nexport let setInternalValue: <T>(signal: ValueSignal<T>, value: T) => void;\n\n/**\n * A signal that holds a value. The underlying\n * value of this signal is stored and updated as a\n * shared value on the server.\n *\n * @internal\n */\nexport abstract class ValueSignal<T> extends Signal<T> {\n  static {\n    setInternalValue = (signal: ValueSignal<unknown>, value: unknown): void => signal.#setInternalValue(value);\n  }\n\n  readonly #publish: (event: StateEvent) => Promise<boolean>;\n\n  /**\n   * Creates a new ValueSignal instance.\n   * @param publish - The function that publishes the\n   * value of the signal to the server.\n   * @param value - The initial value of the signal\n   * @defaultValue undefined\n   */\n  constructor(publish: (event: StateEvent) => Promise<boolean>, value?: T) {\n    super(value);\n    this.#publish = publish;\n  }\n\n  /**\n   * Returns the value of the signal.\n   */\n  override get value(): T {\n    return super.value;\n  }\n\n  /**\n   * Publishes the new value to the server.\n   * Note that this method is not setting\n   * the signal's value.\n   *\n   * @param value - The new value of the signal\n   * to be published to the server.\n   */\n  override set value(value: T) {\n    const id = nanoid();\n    // set the local value to be used for latency compensation and offline support:\n    this.#setInternalValue(value);\n    // publish the update to the server:\n    this.#publish({ id, type: StateEventType.SET, value }).catch((error) => {\n      throw error;\n    });\n  }\n\n  /**\n   * Sets the value of the signal.\n   * @param value - The new value of the signal.\n   * @internal\n   */\n  #setInternalValue(value: T): void {\n    super.value = value;\n  }\n}\n\n/**\n * A signal that holds a number value. The underlying\n * value of this signal is stored and updated as a\n * shared value on the server.\n *\n * After obtaining the NumberSignal instance from\n * a server-side service that returns one, the value\n * can be updated using the `value` property,\n * and it can be read with or without the\n * `value` property (similar to a normal signal):\n *\n * @example\n * ```tsx\n *  const counter = CounterService.counter();\n *\n * return (\n *    <Button onClick={() => counter++)}>\n *      Click count: { counter }\n *    </Button>\n *    <Button onClick={() => counter.value = 0}>Reset</Button>\n * );\n * ```\n */\nexport class NumberSignal extends ValueSignal<number> {}\n"],
-  "mappings": "AAAA,SAAS,cAAc;AACvB,SAAS,cAAc;AACvB,SAA0B,sBAAsB;AAGzC,IAAI;AASJ,MAAe,oBAAuB,OAAU;AAAA,EACrD,OAAO;AACL,uBAAmB,CAAC,QAA8B,UAAyB,OAAO,kBAAkB,KAAK;AAAA,EAC3G;AAAA,EAES;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAST,YAAY,SAAkD,OAAW;AACvE,UAAM,KAAK;AACX,SAAK,WAAW;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA,EAKA,IAAa,QAAW;AACtB,WAAO,MAAM;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,IAAa,MAAM,OAAU;AAC3B,UAAM,KAAK,OAAO;AAElB,SAAK,kBAAkB,KAAK;AAE5B,SAAK,SAAS,EAAE,IAAI,MAAM,eAAe,KAAK,MAAM,CAAC,EAAE,MAAM,CAAC,UAAU;AACtE,YAAM;AAAA,IACR,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,kBAAkB,OAAgB;AAChC,UAAM,QAAQ;AAAA,EAChB;AACF;AAyBO,MAAM,qBAAqB,YAAoB;AAAC;",
-  "names": []
-}

package/SignalsHandler.d.ts

@@ -1,15 +0,0 @@
-import type { ConnectClient, EndpointRequestInit, Subscription } from '@vaadin/hilla-frontend';
-import type { StateEvent } from './types';
-/**
- * SignalsHandler is a helper class for handling the
- * communication of the full-stack signal instances
- * and their server-side counterparts they are
- * subscribed and publish their updates to.
- */
-export default class SignalsHandler {
-    #private;
-    constructor(client: ConnectClient);
-    subscribe(signalProviderEndpointMethod: string, clientSignalId: string): Subscription<StateEvent>;
-    update(clientSignalId: string, event: StateEvent, init?: EndpointRequestInit): Promise<void>;
-}
-//# sourceMappingURL=SignalsHandler.d.ts.map

package/SignalsHandler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SignalsHandler.d.ts","sourceRoot":"","sources":["src/SignalsHandler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC/F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C;;;;;GAKG;AACH,MAAM,CAAC,OAAO,OAAO,cAAc;;gBAGrB,MAAM,EAAE,aAAa;IAIjC,SAAS,CAAC,4BAA4B,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,YAAY,CAAC,UAAU,CAAC;IAI3F,MAAM,CAAC,cAAc,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;CAGnG"}

package/SignalsHandler.js

@@ -1,16 +0,0 @@
-class SignalsHandler {
-  #client;
-  constructor(client) {
-    this.#client = client;
-  }
-  subscribe(signalProviderEndpointMethod, clientSignalId) {
-    return this.#client.subscribe("SignalsHandler", "subscribe", { signalProviderEndpointMethod, clientSignalId });
-  }
-  async update(clientSignalId, event, init) {
-    return this.#client.call("SignalsHandler", "update", { clientSignalId, event }, init);
-  }
-}
-export {
-  SignalsHandler as default
-};
-//# sourceMappingURL=SignalsHandler.js.map

package/SignalsHandler.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["src/SignalsHandler.ts"],
-  "sourcesContent": ["import type { ConnectClient, EndpointRequestInit, Subscription } from '@vaadin/hilla-frontend';\nimport type { StateEvent } from './types';\n\n/**\n * SignalsHandler is a helper class for handling the\n * communication of the full-stack signal instances\n * and their server-side counterparts they are\n * subscribed and publish their updates to.\n */\nexport default class SignalsHandler {\n  readonly #client: ConnectClient;\n\n  constructor(client: ConnectClient) {\n    this.#client = client;\n  }\n\n  subscribe(signalProviderEndpointMethod: string, clientSignalId: string): Subscription<StateEvent> {\n    return this.#client.subscribe('SignalsHandler', 'subscribe', { signalProviderEndpointMethod, clientSignalId });\n  }\n\n  async update(clientSignalId: string, event: StateEvent, init?: EndpointRequestInit): Promise<void> {\n    return this.#client.call('SignalsHandler', 'update', { clientSignalId, event }, init);\n  }\n}\n"],
-  "mappings": "AASA,MAAO,eAA6B;AAAA,EACzB;AAAA,EAET,YAAY,QAAuB;AACjC,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,UAAU,8BAAsC,gBAAkD;AAChG,WAAO,KAAK,QAAQ,UAAU,kBAAkB,aAAa,EAAE,8BAA8B,eAAe,CAAC;AAAA,EAC/G;AAAA,EAEA,MAAM,OAAO,gBAAwB,OAAmB,MAA2C;AACjG,WAAO,KAAK,QAAQ,KAAK,kBAAkB,UAAU,EAAE,gBAAgB,MAAM,GAAG,IAAI;AAAA,EACtF;AACF;",
-  "names": []
-}

package/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,cAAc;IACxB,GAAG,QAAQ;IACX,QAAQ,aAAa;CACtB;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE,GAAG,CAAC;CACZ,CAAC"}

package/types.js

@@ -1,9 +0,0 @@
-var StateEventType = /* @__PURE__ */ ((StateEventType2) => {
-  StateEventType2["SET"] = "set";
-  StateEventType2["SNAPSHOT"] = "snapshot";
-  return StateEventType2;
-})(StateEventType || {});
-export {
-  StateEventType
-};
-//# sourceMappingURL=types.js.map

package/types.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["src/types.ts"],
-  "sourcesContent": ["/**\n * Types of events that can be produced or processed by a signal.\n */\nexport enum StateEventType {\n  SET = 'set',\n  SNAPSHOT = 'snapshot',\n}\n\n/**\n * Event that describes the state of a signal.\n */\nexport type StateEvent = {\n  id: string;\n  type: StateEventType;\n  value: any;\n};\n"],
-  "mappings": "AAGO,IAAK,iBAAL,kBAAKA,oBAAL;AACL,EAAAA,gBAAA,SAAM;AACN,EAAAA,gBAAA,cAAW;AAFD,SAAAA;AAAA,GAAA;",
-  "names": ["StateEventType"]
-}