@vaadin/hilla-react-signals 24.5.0-alpha5 → 24.5.0-alpha7

package/EventChannel.d.ts

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1 @@
+{"version":3,"file":"EventChannel.d.ts","sourceRoot":"","sources":["src/EventChannel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,wBAAwB,CAAC;AAC1E,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

@@ -0,0 +1,55 @@
+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 = crypto.randomUUID();
+    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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/EventChannel.ts"],
+  "sourcesContent": ["import type { ConnectClient, Subscription } from '@vaadin/hilla-frontend';\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 = crypto.randomUUID();\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,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,WAAW;AAC7B,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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1 @@
+{"version":3,"file":"Signals.d.ts","sourceRoot":"","sources":["src/Signals.ts"],"names":[],"mappings":"AAAA,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

@@ -0,0 +1,57 @@
+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 = crypto.randomUUID();
+    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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/Signals.ts"],
+  "sourcesContent": ["import { 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 = crypto.randomUUID();\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,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,WAAW;AAE7B,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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,7 @@
+{
+  "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/core.d.ts

@@ -0,0 +1,2 @@
+export * from '@preact/signals-react';
+//# sourceMappingURL=core.d.ts.map

package/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["src/core.ts"],"names":[],"mappings":"AAKA,cAAc,uBAAuB,CAAC"}

package/core.js

@@ -0,0 +1,4 @@
+import { installAutoSignalTracking } from "@preact/signals-react/runtime";
+installAutoSignalTracking();
+export * from "@preact/signals-react";
+//# sourceMappingURL=core.js.map

package/core.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/core.ts"],
+  "sourcesContent": ["import { installAutoSignalTracking } from '@preact/signals-react/runtime';\n\n// eslint-disable-next-line @typescript-eslint/no-unsafe-call\ninstallAutoSignalTracking();\n\nexport * from '@preact/signals-react';\n"],
+  "mappings": "AAAA,SAAS,iCAAiC;AAG1C,0BAA0B;AAE1B,cAAc;",
+  "names": []
+}

package/index.d.ts

@@ -1,2 +1,5 @@
-export * from '@preact/signals-react';
+export * from './core.js';
+export { NumberSignalChannel } from './EventChannel.js';
+export { NumberSignal, ValueSignal } from './Signals.js';
+export * from './types.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":"AAAA,cAAc,uBAAuB,CAAC"}
+{"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"}

package/index.js

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

package/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["src/index.ts"],
-  "sourcesContent": ["export * from '@preact/signals-react';\n"],
-  "mappings": "AAAA,cAAc;",
+  "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;",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vaadin/hilla-react-signals",
-  "version": "24.5.0-alpha5",
+  "version": "24.5.0-alpha7",
   "description": "Signals for Hilla React",
   "main": "index.js",
   "module": "index.js",
@@ -21,8 +21,11 @@
     "build:esbuild": "tsx ../../../scripts/build.ts",
     "build:dts": "tsc --isolatedModules -p tsconfig.build.json",
     "build:copy": "cd src && copyfiles **/*.d.ts ..",
-    "lint": "eslint src",
-    "lint:fix": "eslint src --fix",
+    "lint": "eslint src test",
+    "lint:fix": "eslint src test --fix",
+    "test": "karma start ../../../karma.config.cjs --port 9881",
+    "test:coverage": "npm run test -- --coverage",
+    "test:watch": "npm run test -- --watch",
     "typecheck": "tsc --noEmit"
   },
   "exports": {
@@ -43,7 +46,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@preact/signals-react": "^2.0.0"
+    "@preact/signals-react": "^2.0.0",
+    "@vaadin/hilla-frontend": "24.5.0-alpha7"
   },
   "peerDependencies": {
     "react": "^18",
@@ -51,10 +55,24 @@
   },
   "devDependencies": {
     "@esm-bundle/chai": "^4.3.4-fix.0",
+    "@testing-library/dom": "^10.2.0",
+    "@testing-library/react": "^16.0.0",
+    "@testing-library/user-event": "^14.5.2",
+    "@types/chai": "^4.3.6",
+    "@types/chai-as-promised": "^7.1.6",
+    "@types/chai-dom": "^1.11.1",
+    "@types/mocha": "^10.0.2",
     "@types/react": "^18.2.23",
     "@types/sinon": "^10.0.17",
+    "@types/sinon-chai": "^3.2.10",
     "@types/validator": "^13.11.2",
-    "react-router-dom": "^6.16.0",
+    "chai-as-promised": "^7.1.1",
+    "chai-dom": "^1.11.0",
+    "chai-like": "^1.1.1",
+    "karma": "^6.4.3",
+    "karma-viewport": "^1.0.9",
+    "sinon": "^16.0.0",
+    "sinon-chai": "^3.7.0",
     "typescript": "5.5.2"
   }
 }

package/types.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Types of events that can be produced or processed by a signal.
+ */
+export declare enum StateEventType {
+    SET = "set",
+    SNAPSHOT = "snapshot"
+}
+/**
+ * Event that describes the state of a signal.
+ */
+export type StateEvent = {
+    id: string;
+    type: StateEventType;
+    value: any;
+};
+//# sourceMappingURL=types.d.ts.map

package/types.d.ts.map

@@ -0,0 +1 @@
+{"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

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

package/types.js.map

@@ -0,0 +1,7 @@
+{
+  "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"]
+}