reactjs-signal 1.0.0 → 1.0.2

package/README.md

@@ -1 +1,382 @@
-# Template create npm package
+<p align="center">
+<a href="https://www.npmjs.com/package/reactjs-signal" target="_blank" rel="noopener noreferrer">
+<img src="https://api.iconify.design/uil:comment-verify.svg?color=%23b3ff75" alt="logo" width='100'/></a>
+</p>
+
+<p align="center">
+  Share Store State with Signal Pattern
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/reactjs-signal" target="_blank" rel="noopener noreferrer"><img src="https://badge.fury.io/js/reactjs-signal.svg" alt="NPM Version" /></a>
+  <a href="https://www.npmjs.com/package/reactjs-signal" target="_blank" rel="noopener noreferrer"><img src="https://img.shields.io/npm/dt/reactjs-signal.svg?logo=npm" alt="NPM Downloads" /></a>
+  <a href="https://bundlephobia.com/result?p=reactjs-signal" target="_blank" rel="noopener noreferrer"><img src="https://img.shields.io/bundlephobia/minzip/reactjs-signal" alt="Minizip" /></a>
+  <a href="https://github.com/hunghg255/reactjs-signal/graphs/contributors" target="_blank" rel="noopener noreferrer"><img src="https://img.shields.io/badge/all_contributors-1-orange.svg" alt="Contributors" /></a>
+  <a href="https://github.com/hunghg255/reactjs-signal/blob/main/LICENSE" target="_blank" rel="noopener noreferrer"><img src="https://badgen.net/github/license/hunghg255/reactjs-signal" alt="License" /></a>
+</p>
+
+## Installation
+
+```bash
+npm install reactjs-signal
+```
+
+
+## Usage
+
+```tsx
+import React from 'react';
+import { useSignal } from 'reactjs-signal';
+
+const App = () => {
+  const [state, setState] = useSignal({ count: 0 });
+
+  return (
+    <div>
+      <h1>{state.count}</h1>
+      <button onClick={() => setState({ count: state.count + 1 })}>Increment</button>
+    </div>
+  );
+};
+```
+
+## API Documentation
+
+### `createSignal`
+
+Creates a writable Alien Signal.
+
+#### Example
+
+```typescript
+const countSignal = createSignal(0);
+countSignal.set(10); // sets the value to 10
+```
+
+#### Parameters
+
+- `initialValue` (`T`): The initial value of the signal.
+
+#### Returns
+
+- `IWritableSignal<T>`: The created Alien Signal.
+
+### `createComputed`
+
+Creates a computed Alien Signal based on a getter function.
+
+#### Example
+
+```typescript
+const countSignal = createSignal(1);
+const doubleSignal = createComputed(() => countSignal.get() * 2);
+```
+
+#### Parameters
+
+- `fn` (`() => T`): A getter function returning a computed value.
+
+#### Returns
+
+- `ISignal<T>`: The created computed signal.
+
+### `createEffect`
+
+Creates a side effect in Alien Signals.
+
+#### Example
+
+```typescript
+const countSignal = createSignal(1);
+createEffect(() => {
+  console.log('Count is', countSignal.get());
+});
+```
+
+#### Parameters
+
+- `fn` (`() => T`): A function that will run whenever its tracked signals update.
+
+#### Returns
+
+- `Effect<T>`: The created effect object.
+
+### `createSignalScope`
+
+Creates an Alien Signals effect scope. This scope can manage multiple effects, allowing you to stop or start them together.
+
+#### Example
+
+```typescript
+const scope = createSignalScope();
+scope.run(() => {
+  // create effects in here...
+});
+```
+
+#### Returns
+
+- `EffectScope`: The created effect scope.
+
+### `unstable_createAsyncComputed`
+
+Creates an async computed signal in Alien Signals. The getter is an async generator that yields dependencies and finally resolves to a computed value.
+
+#### Example
+
+```typescript
+const asyncComp = createAsyncComputed<number>(async function* () {
+  yield someDependency;
+  return 42;
+});
+```
+
+#### Parameters
+
+- `getter` (`() => AsyncGenerator<Dependency, T>`): An async generator returning dependencies and ultimately a value.
+
+#### Returns
+
+- `AsyncComputed<T>`: The created async computed signal.
+
+### `unstable_createAsyncEffect`
+
+Creates an async effect in Alien Signals. The function is an async generator that yields dependencies as they are discovered.
+
+#### Example
+
+```typescript
+createAsyncEffect(async function* () {
+  yield someDependency;
+  console.log('Async effect done!');
+});
+```
+
+#### Parameters
+
+- `fn` (`() => AsyncGenerator<Dependency, T>`): An async generator returning dependencies.
+
+#### Returns
+
+- `Promise<T>`: The created async effect object.
+
+### `unstable_createComputedArray`
+
+Creates a computed array signal in Alien Signals, deriving a reactive array from an original signal array.
+
+#### Example
+
+```typescript
+const numbersSignal = createSignal([1, 2, 3]);
+const compArray = createComputedArray(numbersSignal, (itemSignal, i) => () => {
+  return itemSignal.get() * 2;
+});
+```
+
+#### Parameters
+
+- `arr` (`ISignal<I[]>`): Signal containing an array.
+- `getGetter` (`(itemSignal: ISignal<I>, index: number) => () => O`): A function returning a getter for each item signal.
+
+#### Returns
+
+- `Readonly<O[]>`: A proxied array signal.
+
+### `unstable_createComputedSet`
+
+Creates a computed Set signal in Alien Signals that tracks changes to a source Set signal.
+
+#### Example
+
+```typescript
+const setSignal = createSignal(new Set([1, 2]));
+const compSet = createComputedSet(setSignal);
+```
+
+#### Parameters
+
+- `source` (`IWritableSignal<Set<T>>`): A signal containing a Set.
+
+#### Returns
+
+- `ISignal<Set<T>>`: A computed signal referencing that Set.
+
+### `unstable_createEqualityComputed`
+
+Creates an equality-based computed signal, only updating when the new value is not deeply equal to the old value.
+
+#### Example
+
+```typescript
+const eqComp = createEqualityComputed(() => {
+  return { foo: 'bar' };
+});
+```
+
+#### Parameters
+
+- `getter` (`() => T`): A function returning the value to compare.
+
+#### Returns
+
+- `ISignal<T>`: An equality computed signal.
+
+### `useSignal`
+
+React hook returning `[value, setValue]` for a given Alien Signal. Uses `useSyncExternalStore` for concurrency-safe re-renders.
+
+#### Example
+
+```typescript
+const countSignal = createSignal(0);
+function Counter() {
+  const [count, setCount] = useSignal(countSignal);
+  return <button onClick={() => setCount(count + 1)}>{count}</button>;
+}
+```
+
+#### Parameters
+
+- `alienSignal` (`IWritableSignal<T>`): The signal to read/write.
+
+#### Returns
+
+- `[T, (val: T | ((oldVal: T) => T)) => void]`: A tuple `[currentValue, setValue]`.
+
+### `useSignalValue`
+
+React hook returning only the current value of an Alien Signal (or computed). No setter is provided.
+
+#### Example
+
+```typescript
+const countSignal = createSignal(0);
+const doubleSignal = createComputed(() => countSignal.get() * 2);
+function Display() {
+  const count = useSignalValue(countSignal);
+  const double = useSignalValue(doubleSignal);
+  return <div>{count}, {double}</div>;
+}
+```
+
+#### Parameters
+
+- `alienSignal` (`IWritableSignal<T>`): The signal to read.
+
+#### Returns
+
+- `T`: The current value.
+
+### `useSetSignal`
+
+React hook returning only a setter function for an Alien Signal. No current value is provided, similar to Jotai's `useSetAtom`.
+
+#### Example
+
+```typescript
+const countSignal = createSignal(0);
+function Incrementor() {
+  const setCount = useSetSignal(countSignal);
+  return <button onClick={() => setCount((c) => c + 1)}>+1</button>;
+}
+```
+
+#### Parameters
+
+- `alienSignal` (`IWritableSignal<T>`): The signal to write.
+
+#### Returns
+
+- `(val: T | ((oldVal: T) => T)) => void`: A setter function.
+
+### `useSignalEffect`
+
+React hook for running a side effect whenever Alien Signals' dependencies used in `fn` change. The effect is cleaned up on component unmount.
+
+#### Example
+
+```typescript
+function Logger() {
+  useSignalEffect(() => {
+    console.log('Signal changed:', someSignal.get());
+  });
+  return null;
+}
+```
+
+#### Parameters
+
+- `fn` (`() => void`): The effect function to run.
+
+### `useSignalScope`
+
+React hook for managing an Alien Signals effect scope. All signals/effects created inside this scope run when the component mounts, and are stopped automatically when the component unmounts.
+
+#### Example
+
+```typescript
+function ScopedEffects() {
+  const scope = useSignalScope();
+  useEffect(() => {
+    scope.run(() => {
+      createEffect(() => {
+        console.log('Scoped effect:', someSignal.get());
+      });
+    });
+  }, [scope]);
+  return null;
+}
+```
+
+#### Returns
+
+- `EffectScope`: The created effect scope.
+
+### `unstable_useAsyncComputedValue`
+
+React hook to read from an async computed signal. The hook fetches the current value, subscribing to changes via `useSyncExternalStore`, and triggers a `get()` call to retrieve updated data. Maintains an internal state for the resolved value of the promise.
+
+#### Example
+
+```typescript
+const asyncSignal = createAsyncComputed<number>(async function*() {
+  const val = someSignal.get();
+  yield Promise.resolve(someSignal); // track async dep
+  return val * 2;
+});
+
+function AsyncDisplay() {
+  const value = useAsyncComputedValue(asyncSignal);
+  return <div>Value: {String(value)}</div>;
+}
+```
+
+#### Parameters
+
+- `alienAsyncComp` (`AsyncComputed<T>`): The async computed signal to read.
+
+#### Returns
+
+- `T | undefined`: The resolved value (or undefined if not yet resolved).
+
+### `unstable_useAsyncEffect`
+
+React hook to run an asynchronous effect whenever the component mounts, cleaning up when it unmounts.
+
+#### Example
+
+```typescript
+useAsyncEffect(async function* () {
+  yield someDependency;
+  console.log('Async side effect complete!');
+});
+```
+
+#### Parameters
+
+- `fn` (`() => AsyncGenerator<Dependency, T>`): An async generator representing the effect logic.
+
+
+## Refer
+
+ React Alien Signals is a **TypeScript** library that provides hooks built on top of [Alien Signals](https://github.com/stackblitz/alien-signals).

package/{src/index.ts → dist/index.d.ts}

@@ -1,4 +1,5 @@
-'use client';
+import { IWritableSignal, ISignal, Effect, EffectScope, Dependency, Computed } from 'alien-signals';
+
 /**
  *
  * React Alien Signals is a **TypeScript** library that provides hooks built on top of [Alien Signals](https://github.com/stackblitz/alien-signals).
@@ -7,27 +8,10 @@
  * @module reactjs-signal
  */
 
-import {
-  computed as alienComputed,
-  effect as alienEffect,
-  effectScope as alienEffectScope,
-  signal as alienSignal,
-  unstable as alienUnstable,
-  type Effect,
-  type Computed,
-  type Dependency,
-  type EffectScope,
-  type ISignal,
-  type IWritableSignal,
-} from 'alien-signals';
-import { useEffect, useMemo, useState, useSyncExternalStore } from 'react';
-
 declare class AsyncComputed<T = any> extends Computed {
-  get(): Promise<T>;
-  //@ts-ignore
-  update(): Promise<boolean>;
+    get(): Promise<T>;
+    update(): Promise<boolean>;
 }
-
 /**
  * Creates a writable Alien Signal.
  *
@@ -41,10 +25,7 @@ declare class AsyncComputed<T = any> extends Computed {
  * @param {T} initialValue - The initial value of the signal.
  * @returns {IWritableSignal<T>} The created Alien Signal.
  */
-export function createSignal<T>(initialValue: T): IWritableSignal<T> {
-  return alienSignal<T>(initialValue);
-}
-
+declare function createSignal<T>(initialValue: T): IWritableSignal<T>;
 /**
  * Creates a computed Alien Signal based on a getter function.
  *
@@ -58,10 +39,7 @@ export function createSignal<T>(initialValue: T): IWritableSignal<T> {
  * @param {() => T} fn - A getter function returning a computed value.
  * @returns {ISignal<T>} The created computed signal.
  */
-export function createComputed<T>(fn: () => T): ISignal<T> {
-  return alienComputed<T>(fn);
-}
-
+declare function createComputed<T>(fn: () => T): ISignal<T>;
 /**
  * Creates a side effect in Alien Signals.
  *
@@ -77,10 +55,7 @@ export function createComputed<T>(fn: () => T): ISignal<T> {
  * @param {() => T} fn - A function that will run whenever its tracked signals update.
  * @returns {Effect<T>} The created effect object.
  */
-export function createEffect<T>(fn: () => T): Effect<T> {
-  return alienEffect(fn);
-}
-
+declare function createEffect<T>(fn: () => T): Effect<T>;
 /**
  * Creates an Alien Signals effect scope. This scope can manage multiple effects,
  * allowing you to stop or start them together.
@@ -95,10 +70,7 @@ export function createEffect<T>(fn: () => T): Effect<T> {
  *
  * @returns {EffectScope} The created effect scope.
  */
-export function createSignalScope(): EffectScope {
-  return alienEffectScope();
-}
-
+declare function createSignalScope(): EffectScope;
 /**
  * Creates an async computed signal in Alien Signals. The getter is an async generator
  * that yields dependencies and finally resolves to a computed value.
@@ -116,12 +88,7 @@ export function createSignalScope(): EffectScope {
  * @returns {AsyncComputed<T>} The created async computed signal.
  * @experimental
  */
-export function unstable_createAsyncComputed<T>(
-  getter: () => AsyncGenerator<Dependency, T>,
-): AsyncComputed<T> {
-  return alienUnstable.asyncComputed<T>(getter);
-}
-
+declare function unstable_createAsyncComputed<T>(getter: () => AsyncGenerator<Dependency, T>): AsyncComputed<T>;
 /**
  * Creates an async effect in Alien Signals. The function is an async generator
  * that yields dependencies as they are discovered.
@@ -138,16 +105,7 @@ export function unstable_createAsyncComputed<T>(
  * @param {() => AsyncGenerator<Dependency, T>} fn - An async generator returning dependencies.
  * @returns {Promise<T>} The created async effect object.
  */
-export async function unstable_createAsyncEffect<T>(
-  fn: () => AsyncGenerator<Dependency, T>,
-): Promise<T> {
-  const eff = alienUnstable.asyncEffect(fn);
-
-  // Immediately run the effect and return its promise
-  const final = await eff.run();
-  return final;
-}
-
+declare function unstable_createAsyncEffect<T>(fn: () => AsyncGenerator<Dependency, T>): Promise<T>;
 /**
  * Creates a computed array signal in Alien Signals, deriving a reactive
  * array from an original signal array.
@@ -167,13 +125,7 @@ export async function unstable_createAsyncEffect<T>(
  * @returns {Readonly<O[]>} A proxied array signal.
  * @experimental
  */
-export function unstable_createComputedArray<I, O>(
-  arr: ISignal<I[]>,
-  getGetter: (itemSignal: ISignal<I>, index: number) => () => O,
-): Readonly<O[]> {
-  return alienUnstable.computedArray<I, O>(arr, getGetter);
-}
-
+declare function unstable_createComputedArray<I, O>(arr: ISignal<I[]>, getGetter: (itemSignal: ISignal<I>, index: number) => () => O): Readonly<O[]>;
 /**
  * Creates a computed Set signal in Alien Signals that tracks changes
  * to a source Set signal.
@@ -189,10 +141,7 @@ export function unstable_createComputedArray<I, O>(
  * @returns {ISignal<Set<T>>} A computed signal referencing that Set.
  * @experimental
  */
-export function unstable_createComputedSet<T>(source: IWritableSignal<Set<T>>): ISignal<Set<T>> {
-  return alienUnstable.computedSet<T>(source);
-}
-
+declare function unstable_createComputedSet<T>(source: IWritableSignal<Set<T>>): ISignal<Set<T>>;
 /**
  * Creates an equality-based computed signal, only updating when the new value
  * is not deeply equal to the old value.
@@ -209,10 +158,7 @@ export function unstable_createComputedSet<T>(source: IWritableSignal<Set<T>>):
  * @returns {ISignal<T>} An equality computed signal.
  * @experimental
  */
-export function unstable_createEqualityComputed<T>(getter: () => T): ISignal<T> {
-  return alienUnstable.equalityComputed(getter);
-}
-
+declare function unstable_createEqualityComputed<T>(getter: () => T): ISignal<T>;
 /**
  * React hook returning `[value, setValue]` for a given Alien Signal.
  * Uses useSyncExternalStore for concurrency-safe re-renders.
@@ -230,32 +176,7 @@ export function unstable_createEqualityComputed<T>(getter: () => T): ISignal<T>
  * @param {IWritableSignal<T>} alienSignal - The signal to read/write.
  * @returns {[T, (val: T | ((oldVal: T) => T)) => void]} A tuple [currentValue, setValue].
  */
-export function useSignal<T>(
-  alienSignal: IWritableSignal<T>,
-): [T, (val: T | ((oldVal: T) => T)) => void] {
-  const value = useSyncExternalStore(
-    (callback) => {
-      const eff = alienEffect(() => {
-        alienSignal.get(); // track
-        callback();
-      });
-      return () => eff.stop();
-    },
-    () => alienSignal.get(),
-    () => alienSignal.get(), // server snapshot
-  );
-
-  const setValue = (val: T | ((oldVal: T) => T)) => {
-    if (typeof val === 'function') {
-      alienSignal.set((val as (oldVal: T) => T)(alienSignal.get()));
-    } else {
-      alienSignal.set(val);
-    }
-  };
-
-  return [value, setValue];
-}
-
+declare function useSignal<T>(alienSignal: IWritableSignal<T>): [T, (val: T | ((oldVal: T) => T)) => void];
 /**
  * React hook returning only the current value of an Alien Signal (or computed).
  * No setter is provided.
@@ -275,19 +196,7 @@ export function useSignal<T>(
  * @param {IWritableSignal<T>} alienSignal - The signal to read.
  * @returns {T} The current value.
  */
-export function useSignalValue<T>(alienSignal: IWritableSignal<T>): T {
-  return useSyncExternalStore(
-    (callback) => {
-      const eff = alienEffect(() => {
-        alienSignal.get();
-        callback();
-      });
-      return () => eff.stop();
-    },
-    () => alienSignal.get(),
-  );
-}
-
+declare function useSignalValue<T>(alienSignal: IWritableSignal<T>): T;
 /**
  * React hook returning only a setter function for an Alien Signal.
  * No current value is provided, similar to Jotai's useSetAtom.
@@ -305,18 +214,7 @@ export function useSignalValue<T>(alienSignal: IWritableSignal<T>): T {
  * @param {IWritableSignal<T>} alienSignal - The signal to write.
  * @returns {(val: T | ((oldVal: T) => T)) => void} A setter function.
  */
-export function useSetSignal<T>(
-  alienSignal: IWritableSignal<T>,
-): (val: T | ((oldVal: T) => T)) => void {
-  return (val) => {
-    if (typeof val === 'function') {
-      alienSignal.set((val as (oldVal: T) => T)(alienSignal.get()));
-    } else {
-      alienSignal.set(val);
-    }
-  };
-}
-
+declare function useSetSignal<T>(alienSignal: IWritableSignal<T>): (val: T | ((oldVal: T) => T)) => void;
 /**
  * React hook for running a side effect whenever Alien Signals' dependencies
  * used in `fn` change. The effect is cleaned up on component unmount.
@@ -333,13 +231,7 @@ export function useSetSignal<T>(
  *
  * @param {() => void} fn - The effect function to run.
  */
-export function useSignalEffect(fn: () => void): void {
-  useEffect(() => {
-    const eff = alienEffect(fn);
-    return () => eff.stop();
-  }, [fn]);
-}
-
+declare function useSignalEffect(fn: () => void): void;
 /**
  * React hook for managing an Alien Signals effect scope.
  * All signals/effects created inside this scope run when the component mounts,
@@ -362,16 +254,7 @@ export function useSignalEffect(fn: () => void): void {
  *
  * @returns {EffectScope} The created effect scope.
  */
-export function useSignalScope(): EffectScope {
-  const scope = useMemo(() => alienEffectScope(), []);
-  useEffect(() => {
-    return () => {
-      scope.stop();
-    };
-  }, [scope]);
-  return scope;
-}
-
+declare function useSignalScope(): EffectScope;
 /**
  * React hook to read from an async computed signal.
  * The hook fetches the current value, subscribing to changes via useSyncExternalStore,
@@ -397,35 +280,7 @@ export function useSignalScope(): EffectScope {
  * @returns {T | undefined} The resolved value (or undefined if not yet resolved).
  * @experimental
  */
-export function unstable_useAsyncComputedValue<T>(alienAsyncComp: AsyncComputed<T>): T | undefined {
-  const [value, setValue] = useState<T | undefined>(alienAsyncComp.currentValue);
-
-  useSyncExternalStore(
-    (callback) => {
-      const eff = alienEffect(() => {
-        alienAsyncComp.currentValue; // track
-        callback();
-      });
-      return () => eff.stop();
-    },
-    () => alienAsyncComp.currentValue,
-  );
-
-  useEffect(() => {
-    let active = true;
-    const fetchValue = async () => {
-      const val = await alienAsyncComp.get();
-      if (active) setValue(val);
-    };
-    fetchValue();
-    return () => {
-      active = false;
-    };
-  }, [alienAsyncComp]);
-
-  return value;
-}
-
+declare function unstable_useAsyncComputedValue<T>(alienAsyncComp: AsyncComputed<T>): T | undefined;
 /**
  * React hook to run an asynchronous effect whenever the component mounts,
  * cleaning up when it unmounts.
@@ -442,9 +297,6 @@ export function unstable_useAsyncComputedValue<T>(alienAsyncComp: AsyncComputed<
  * @param {() => AsyncGenerator<Dependency, T>} fn - An async generator representing the effect logic.
  * @experimental
  */
-export function unstable_useAsyncEffect<T>(fn: () => AsyncGenerator<Dependency, T>): void {
-  useEffect(() => {
-    const eff = alienUnstable.asyncEffect(fn);
-    return () => eff.stop();
-  }, [fn]);
-}
+declare function unstable_useAsyncEffect<T>(fn: () => AsyncGenerator<Dependency, T>): void;
+
+export { createComputed, createEffect, createSignal, createSignalScope, unstable_createAsyncComputed, unstable_createAsyncEffect, unstable_createComputedArray, unstable_createComputedSet, unstable_createEqualityComputed, unstable_useAsyncComputedValue, unstable_useAsyncEffect, useSetSignal, useSignal, useSignalEffect, useSignalScope, useSignalValue };

package/dist/index.js

@@ -0,0 +1 @@
+import {signal,computed,effect,effectScope,unstable}from'alien-signals';import {useSyncExternalStore,useEffect,useMemo,useState}from'react';function g(e){return signal(e)}function m(e){return computed(e)}function x(e){return effect(e)}function b(){return effectScope()}function E(e){return unstable.asyncComputed(e)}async function I(e){return await unstable.asyncEffect(e).run()}function V(e,t){return unstable.computedArray(e,t)}function C(e){return unstable.computedSet(e)}function v(e){return unstable.equalityComputed(e)}function A(e){return [useSyncExternalStore(n=>{let c=effect(()=>{e.get(),n();});return ()=>c.stop()},()=>e.get(),()=>e.get()),n=>{typeof n=="function"?e.set(n(e.get())):e.set(n);}]}function _(e){return useSyncExternalStore(t=>{let o=effect(()=>{e.get(),t();});return ()=>o.stop()},()=>e.get())}function W(e){return t=>{typeof t=="function"?e.set(t(e.get())):e.set(t);}}function D(e){useEffect(()=>{let t=effect(e);return ()=>t.stop()},[e]);}function O(){let e=useMemo(()=>effectScope(),[]);return useEffect(()=>()=>{e.stop();},[e]),e}function G(e){let[t,o]=useState(e.currentValue);return useSyncExternalStore(n=>{let c=effect(()=>{e.currentValue,n();});return ()=>c.stop()},()=>e.currentValue),useEffect(()=>{let n=!0;return (async()=>{let l=await e.get();n&&o(l);})(),()=>{n=!1;}},[e]),t}function P(e){useEffect(()=>{let t=unstable.asyncEffect(e);return ()=>t.stop()},[e]);}export{m as createComputed,x as createEffect,g as createSignal,b as createSignalScope,E as unstable_createAsyncComputed,I as unstable_createAsyncEffect,V as unstable_createComputedArray,C as unstable_createComputedSet,v as unstable_createEqualityComputed,G as unstable_useAsyncComputedValue,P as unstable_useAsyncEffect,W as useSetSignal,A as useSignal,D as useSignalEffect,O as useSignalScope,_ as useSignalValue};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactjs-signal",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -8,9 +8,13 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
     }
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsup",
     "watch": "npm run build -- --watch src",
@@ -40,5 +44,13 @@
   "peerDependencies": {
     "alien-signals": ">=0.4",
     "react": ">=18"
+  },
+  "bugs": {
+    "url": "https://github.com/hunghg255/reactjs-signal/issues"
+  },
+  "homepage": "https://github.com/hunghg255/reactjs-signal#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hunghg255/reactjs-signal.git"
   }
 }

package/.github/commit-convention.md

@@ -1,95 +0,0 @@
-## Git Commit Message Convention
-
-> This is adapted from [Commit convention](https://www.conventionalcommits.org/en/v1.0.0/).
-
-#### TL;DR:
-
-Messages must be matched by the following regex:
-
-```js
-/^((feat|fix|docs|style|core|i18n|report|misc|cli|audits|refactor|perf|test|workflow|build|ci|chore|types|wip|release|deps?|merge|examples?|revert)(\(.+\))?(\:|\!\:)|(Merge|Revert|Version)) .{1,50}$/;
-```
-
-#### Examples
-
-Appears under "Features" header, `compiler` subheader:
-
-```
-feat(compiler): add 'comments' option
-```
-
-Appears under "Bug Fixes" header, `v-model` subheader, with a link to issue #28:
-
-```
-fix(v-model): handle events on blur
-
-close #28
-```
-
-Appears under "Performance Improvements" header, and under "Breaking Changes" with the breaking change explanation:
-
-```
-perf(core): improve vdom diffing by removing 'foo' option
-
-BREAKING CHANGE: The 'foo' option has been removed.
-```
-
-The following commit and commit `667ecc1` do not appear in the changelog if they are under the same release. If not, the revert commit appears under the "Reverts" header.
-
-```
-revert: feat(compiler): add 'comments' option
-
-This reverts commit 667ecc1654a317a13331b17617d973392f415f02.
-```
-
-### Full Message Format
-
-A commit message consists of a **header**, **body** and **footer**. The header has a **type**, **scope** and **subject**:
-
-```
-<type>(<scope>): <subject>
-<BLANK LINE>
-<body>
-<BLANK LINE>
-<footer>
-```
-
-The **header** is mandatory and the **scope** of the header is optional.
-
-### Revert
-
-If the commit reverts a previous commit, it should begin with `revert: `, followed by the header of the reverted commit. In the body, it should say: `This reverts commit <hash>.`, where the hash is the SHA of the commit being reverted.
-
-### Type
-
-If the prefix is `feat`, `fix` or `perf`, it will appear in the changelog. However, if there is any [BREAKING CHANGE](#footer), the commit will always appear in the changelog.
-
-Other prefixes are up to your discretion. Suggested prefixes are `docs`, `chore`, `style`, `refactor`, and `test` for non-changelog related tasks.
-
-### Scope
-
-The scope could be anything specifying the place of the commit change. For example `core`, `compiler`, `ssr`, `v-model`, `transition` etc...
-
-### Subject
-
-The subject contains a succinct description of the change:
-
-- use the imperative, present tense: "change" not "changed" nor "changes"
-- don't capitalize the first letter
-- no dot (.) at the end
-
-### Body
-
-Just as in the **subject**, use the imperative, present tense: "change" not "changed" nor "changes".
-The body should include the motivation for the change and contrast this with previous behavior.
-
-### Footer
-
-The footer should contain any information about **Breaking Changes** and is also the place to
-reference GitHub issues that this commit **Closes**.
-
-**Breaking Changes** should start with the word `BREAKING CHANGE:` with a space or two newlines. The rest of the commit message is then used for this.
-
-```
-feat!: breaking change / feat(scope)!: rework API
-```

package/.github/workflows/main.yml

@@ -1,21 +0,0 @@
-name: CI
-on:
-  push:
-    branches:
-      - master
-
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 18.x
-
-      - run: npm install
-      - run: npm run lint && npm run build

package/.github/workflows/release.yml

@@ -1,29 +0,0 @@
-name: Release
-
-permissions:
-  contents: write
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 18.x
-
-      - run: npx changeloggithub@latest
-        env:
-          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
-
-      - name: Publish
-        run: |
-          echo "Publishing"

package/tsconfig.json

@@ -1,26 +0,0 @@
-{
-  "compilerOptions": {
-    // Enable latest features
-    "lib": ["ESNext", "DOM"],
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleDetection": "force",
-    "allowJs": true,
-
-    // Bundler mode
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "noEmit": true,
-
-    // Best practices
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-
-    // Some stricter flags (disabled by default)
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
-  }
-}

package/tsup.config.ts

@@ -1,12 +0,0 @@
-import { defineConfig } from "tsup";
-
-export default defineConfig({
-  entry: ["src/index.ts"],
-  format: "esm",
-  treeshake: true,
-  clean: true,
-  dts: true,
-  platform: "browser",
-  splitting: true,
-  minify: true,
-});