bansa 0.0.1 → 0.0.2

package/dist/index.browser.js

@@ -0,0 +1 @@
+var l=function(){};l.prototype.get=function(){if(this.n||(h(this),i(this)),this.state.promise)throw this.state.promise;if(this.state.error)throw this.state.error;return this.state.value};l.prototype.watch=function(e){return this.n||S(this),(this.l??=new Set).add(e),()=>{this.l.delete(e),this.l.size||i(this)}};l.prototype.subscribe=function(e){let t={f:e,V:{get signal(){return(t.t??=P()).signal}}};if(!this.n)S(this);else if(!this.state.promise&&!this.state.error)try{e(this.state.value,t.V)}catch(o){console.error(o)}return(this.s??=new Set).add(t),()=>{this.s.delete(t),t.t&&(t.t.abort(),t.t=void 0),this.s.size||i(this)}};l.prototype[Symbol.toPrimitive]=function(){return this.state.value};var s=function(e,t){this.c=t?.equals,this.state={promise:void 0,error:void 0,value:e},this.state.value=this.a=e};s.prototype.set=function(e){let t=e instanceof Function?e(this.a):e;y(t,this.state.value,this.c)||(this.a=t,A(this))};s.prototype.m=!0;s.prototype.n=!0;s.prototype.o=!1;Object.setPrototypeOf(s.prototype,l.prototype);var u=function(e,t){this.y=e,this.c=t?.equals,this.b=t?.persist,this.state={promise:v,error:void 0,value:void 0};let o=this;this.V={get signal(){return(o.t??=P()).signal}}};u.prototype.m=!1;u.prototype.n=!1;u.prototype.o=!1;u.prototype.i=0;Object.setPrototypeOf(u.prototype,l.prototype);var V=()=>V,g=()=>{};Object.setPrototypeOf(V,new Proxy(V,{get:(e,t)=>t===Symbol.toPrimitive?g:V}));var v=Promise.resolve(),k=(e,t)=>e instanceof Function?new u(e,t):new s(e,t),O=e=>k((t,o)=>{let r,n,m=e(x=>{try{return t(x)}catch(p){if(!p)throw p;b(p)?(r??=[]).push(p):n=p}return V},o);if(n)throw n;if(r)throw Promise.all(r);return m}),f=!1,a=[],S=e=>{e.u||(e.u=!0,A(e))},A=e=>{e.o||(e.o=!0,a.push(e),f||(f=!0,queueMicrotask(_)))},_=()=>{f=!1;{let t=a;a=[];for(let o of t)o.state.promise=void 0,o.state.error=o.A,o.state.value=o.a,I(o)}let e=a;a=[];for(let t=e.length;t--;){let o=e[t];o.d=!1,o.u&&(o.o=!0,h(o)),o.o&&w(o)}},w=e=>{if(e.o=!1,e.r)for(let t of e.r)t.u=!0;if(e.l)for(let t of e.l)t();if(e.s&&!e.state.promise&&!e.state.error)for(let t of e.s){t.t&&(t.t.abort(),t.t=void 0);try{t.f(e.state.value,t.V)}catch(o){console.error(o)}}},I=e=>{if(!e.d){if(e.d=!0,e.r)for(let t of e.r)I(t);a.push(e)}},c=class{e;constructor(t){this.e=t}},h=e=>{let t=++e.i;e.n=!0,e.u=!1,e.state.promise=void 0,e.t&&(e.t.abort(),e.t=void 0);let o=e.p;o&&(e.p=new Set);try{let r=e.y((n,m=!0)=>{if(t!==e.i)throw void 0;if(e!==n&&(n.n||(h(n),n.o&&(n.o=!1,w(n))),o?.delete(n),(e.p??=new Set).add(n),(n.r??=new Set).add(e)),!m)return n.state;if(n.state.promise)throw new c(n.state.promise);if(n.state.error)throw new c(n.state.error);return n.state.value},e.V);b(r)?(e.state.promise=r,r.then(n=>{t===e.i&&(y(n,e.state.value,e.c)?e.state.promise=void 0:(e.a=n,e.A=void 0,A(e)))},n=>{t===e.i&&(n instanceof Promise?e.state.promise=void 0:(e.A=n,A(e)))})):(++e.i,e.state.error=void 0,y(r,e.state.value,e.c)?e.o=!1:e.state.value=e.a=r)}catch(r){++e.i,r?(r instanceof c?r=r.e:console.error(r),b(r)?e.state.promise=r:e.state.error=r):e.o=!1}if(o)for(let r of o)r.r.delete(e),i(r)},d=!1,i=e=>{if(!e.m&&!e.b&&!e.r?.size&&!e.l?.size&&!e.s?.size){if(!d){setTimeout(()=>{d=!0,i(e),d=!1},0);return}if(e.state.promise=v,e.a=e.A=e.state.error=e.state.value=void 0,e.o=e.u=e.n=!1,e.t&&(e.t.abort(),e.t=void 0),e.p){for(let t of e.p)t.r.delete(e),i(t);e.p.clear()}}},y=(e,t,o)=>Object.is(e,t)||o!==void 0&&t!==void 0&&o(e,t),b=e=>typeof e?.then=="function",P=()=>{let e=new AbortController,t=e.signal,o=new Promise(r=>{t.then=n=>o.then(n),t.addEventListener("abort",r,{once:!0,passive:!0})});return{abort:()=>e.abort(),signal:t}};export{k as $,O as $$,v as inactive};

package/dist/index.d.ts

@@ -0,0 +1,80 @@
+export type Atom<Value> = PrimitiveAtom<Value> | DerivedAtom<Value>;
+export type CommonAtom<Value> = {
+    readonly get: () => Value;
+    readonly watch: (watcher: AtomWatcher) => () => void;
+    readonly subscribe: (subscriber: AtomSubscribe<Value>) => () => void;
+    readonly state: AtomState<Value>;
+};
+export type PrimitiveAtom<Value> = CommonAtom<Value> & {
+    readonly set: (value: AtomUpdater<Value>) => void;
+    readonly state: AtomSuccessState<Value>;
+};
+export type DerivedAtom<Value> = CommonAtom<Value>;
+export type AtomWatcher = () => void;
+export type AtomSubscribe<Value> = (value: Value, options: AtomSubscriberOptions) => void;
+export type AtomInit<Value> = Value | AtomGetter<Value>;
+export type AtomUpdater<Value> = Value | AtomReducer<Value>;
+export type AtomInactiveState<Value> = {
+    promise: typeof inactive;
+    error: any;
+    value?: Value;
+};
+export type AtomPromiseState<Value> = {
+    promise: PromiseLike<Value>;
+    error: any;
+    value?: Value;
+};
+export type AtomSuccessState<Value> = {
+    promise: undefined;
+    error: undefined;
+    value: Value;
+};
+export type AtomErrorState<Value> = {
+    promise: undefined;
+    error: any;
+    value?: Value;
+};
+export type AtomState<Value> = AtomInactiveState<Value> | AtomPromiseState<Value> | AtomSuccessState<Value> | AtomErrorState<Value>;
+export type AtomSubscriberOptions = {
+    readonly signal: ThenableSignal;
+};
+export type AtomGetter<Value> = (get: GetAtom, options: AtomGetOptions) => Value | PromiseLike<Value>;
+export type AtomReducer<Value> = (value: Value) => Value;
+export type AtomGetOptions = {
+    readonly signal: ThenableSignal;
+};
+export type ThenableSignal = AbortSignal & {
+    then: (f: () => void) => void;
+};
+export type GetAtom = {
+    <Value>(anotherAtom: Atom<Value>, unwrap?: true): Value;
+    <Value>(anotherAtom: Atom<Value>, unwrap: false): AtomState<Value>;
+};
+type CreateAtom = {
+    <Value>(init: AtomGetter<Value>, options?: AtomOptions<Value>): DerivedAtom<Value>;
+    <Value>(init: Value, options?: AtomOptions<Value>): PrimitiveAtom<Value>;
+    <Value>(init: Value | AtomGetter<Value>, options?: AtomOptions<Value>): Atom<Value>;
+};
+export type AtomOptions<Value> = {
+    equals?: AtomEquals<Value>;
+    persist?: boolean;
+    eager?: boolean;
+};
+export type AtomEquals<Value> = (value: Value, prevValue: Value) => boolean;
+export type AtomScope = {
+    <Value>(baseAtom: PrimitiveAtom<Value>): PrimitiveAtom<Value>;
+    <Value>(baseAtom: DerivedAtom<Value>): DerivedAtom<Value>;
+    <Value>(baseAtom: Atom<Value>): Atom<Value>;
+} & {
+    get: {
+        <Value>(baseAtom: PrimitiveAtom<Value>): PrimitiveAtom<Value>;
+        <Value>(baseAtom: DerivedAtom<Value>): DerivedAtom<Value>;
+        <Value>(baseAtom: Atom<Value>): Atom<Value>;
+    };
+};
+export type SetLike<Key> = Key[] | Set<Key> | (Key extends object ? WeakSet<Key> : never);
+export type MapLike<Key, Value> = Map<Key, Value> | (Key extends object ? WeakMap<Key, Value> : never) | (Key extends string | number | symbol ? Record<Key, Value> : never);
+export declare const inactive: Promise<void>;
+export declare const $: CreateAtom;
+export declare const $$: <Value>(init: AtomGetter<Value>) => DerivedAtom<Value>;
+export {};

package/dist/index.js

@@ -0,0 +1,368 @@
+const AtomPrototype = function() {
+};
+AtomPrototype.prototype.get = function() {
+  if (!this.c) {
+    execute(this);
+    disableAtom(this);
+  }
+  if (this.state.promise) throw this.state.promise;
+  if (this.state.error) throw this.state.error;
+  return this.state.value;
+};
+AtomPrototype.prototype.watch = function(watcher) {
+  if (!this.c) {
+    requestActivate(this);
+  }
+  (this.h ??= /* @__PURE__ */ new Set()).add(watcher);
+  return () => {
+    this.h.delete(watcher);
+    if (!this.h.size) {
+      disableAtom(this);
+    }
+  };
+};
+AtomPrototype.prototype.subscribe = function(subscriber) {
+  const atomSubscriber = {
+    q: subscriber,
+    l: {
+      get signal() {
+        return (atomSubscriber.a ??= createThenableSignal()).signal;
+      }
+    }
+  };
+  if (!this.c) {
+    requestActivate(this);
+  } else if (!this.state.promise && !this.state.error) {
+    try {
+      subscriber(this.state.value, atomSubscriber.l);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+  (this.i ??= /* @__PURE__ */ new Set()).add(atomSubscriber);
+  return () => {
+    this.i.delete(atomSubscriber);
+    if (atomSubscriber.a) {
+      atomSubscriber.a.abort();
+      atomSubscriber.a = void 0;
+    }
+    if (!this.i.size) {
+      disableAtom(this);
+    }
+  };
+};
+AtomPrototype.prototype[Symbol.toPrimitive] = function() {
+  return this.state.value;
+};
+const PrimitiveAtomPrototype = function(init, options) {
+  this.m = options?.equals;
+  this.state = {
+    promise: void 0,
+    error: void 0,
+    value: init
+  };
+  this.state.value = this.f = init;
+};
+PrimitiveAtomPrototype.prototype.set = function(value) {
+  const nextValue = value instanceof Function ? value(this.f) : value;
+  if (!equals(nextValue, this.state.value, this.m)) {
+    this.f = nextValue;
+    requestPropagate(this);
+  }
+};
+PrimitiveAtomPrototype.prototype.o = true;
+PrimitiveAtomPrototype.prototype.c = true;
+PrimitiveAtomPrototype.prototype.b = false;
+Object.setPrototypeOf(
+  PrimitiveAtomPrototype.prototype,
+  AtomPrototype.prototype
+);
+const DerivedAtomPrototype = function(init, options) {
+  this.r = init;
+  this.m = options?.equals;
+  this.s = options?.persist;
+  this.state = {
+    promise: inactive,
+    error: void 0,
+    value: void 0
+  };
+  const self = this;
+  this.l = {
+    get signal() {
+      return (self.a ??= createThenableSignal()).signal;
+    }
+  };
+};
+DerivedAtomPrototype.prototype.o = false;
+DerivedAtomPrototype.prototype.c = false;
+DerivedAtomPrototype.prototype.b = false;
+DerivedAtomPrototype.prototype.g = 0;
+Object.setPrototypeOf(DerivedAtomPrototype.prototype, AtomPrototype.prototype);
+const ouroboros = () => ouroboros;
+const toUndefined = () => void 0;
+Object.setPrototypeOf(
+  ouroboros,
+  new Proxy(ouroboros, {
+    get: (_, k) => k === Symbol.toPrimitive ? toUndefined : ouroboros
+  })
+);
+const inactive = Promise.resolve();
+const $ = (init, options) => {
+  if (init instanceof Function)
+    return new DerivedAtomPrototype(init, options);
+  return new PrimitiveAtomPrototype(init, options);
+};
+const $$ = (init) => $((get, options) => {
+  let promises;
+  let error;
+  const result = init((atom) => {
+    try {
+      return get(atom);
+    } catch (e) {
+      if (!e) {
+        throw e;
+      }
+      if (isPromiseLike(e)) {
+        (promises ??= []).push(e);
+      } else {
+        error = e;
+      }
+    }
+    return ouroboros;
+  }, options);
+  if (error) throw error;
+  if (promises) throw Promise.all(promises);
+  return result;
+});
+let pendingUpdateAtoms = false;
+let stack = [];
+const requestActivate = (atom) => {
+  if (!atom.j) {
+    atom.j = true;
+    requestPropagate(atom);
+  }
+};
+const requestPropagate = (atom) => {
+  if (!atom.b) {
+    atom.b = true;
+    stack.push(atom);
+    if (!pendingUpdateAtoms) {
+      pendingUpdateAtoms = true;
+      queueMicrotask(updateAtoms);
+    }
+  }
+};
+const updateAtoms = () => {
+  pendingUpdateAtoms = false;
+  {
+    const updatedAtoms = stack;
+    stack = [];
+    for (const atom of updatedAtoms) {
+      atom.state.promise = void 0;
+      atom.state.error = atom.n;
+      atom.state.value = atom.f;
+      mark(atom);
+    }
+  }
+  const markedAtoms = stack;
+  stack = [];
+  for (let i = markedAtoms.length; i--; ) {
+    const atom = markedAtoms[i];
+    atom.p = false;
+    if (atom.j) {
+      atom.b = true;
+      execute(atom);
+    }
+    if (atom.b) {
+      propagate(atom);
+    }
+  }
+};
+const propagate = (atom) => {
+  atom.b = false;
+  if (atom.d) {
+    for (const child of atom.d) {
+      child.j = true;
+    }
+  }
+  if (atom.h) {
+    for (const watcher of atom.h) {
+      watcher();
+    }
+  }
+  if (atom.i && !atom.state.promise && !atom.state.error) {
+    for (const subscriber of atom.i) {
+      if (subscriber.a) {
+        subscriber.a.abort();
+        subscriber.a = void 0;
+      }
+      try {
+        subscriber.q(atom.state.value, subscriber.l);
+      } catch (e) {
+        console.error(e);
+      }
+    }
+  }
+};
+const mark = (atom) => {
+  if (!atom.p) {
+    atom.p = true;
+    if (atom.d) {
+      for (const child of atom.d) {
+        mark(child);
+      }
+    }
+    stack.push(atom);
+  }
+};
+class Wrapped {
+  e;
+  constructor(e) {
+    this.e = e;
+  }
+}
+const execute = (atom) => {
+  const counter = ++atom.g;
+  atom.c = true;
+  atom.j = false;
+  atom.state.promise = void 0;
+  if (atom.a) {
+    atom.a.abort();
+    atom.a = void 0;
+  }
+  const oldDependencies = atom.k;
+  if (oldDependencies) {
+    atom.k = /* @__PURE__ */ new Set();
+  }
+  try {
+    const value = atom.r(
+      (anotherAtom, unwrap = true) => {
+        if (counter !== atom.g) throw void 0;
+        if (atom !== anotherAtom) {
+          if (!anotherAtom.c) {
+            execute(anotherAtom);
+            if (anotherAtom.b) {
+              anotherAtom.b = false;
+              propagate(anotherAtom);
+            }
+          }
+          oldDependencies?.delete(anotherAtom);
+          (atom.k ??= /* @__PURE__ */ new Set()).add(anotherAtom);
+          (anotherAtom.d ??= /* @__PURE__ */ new Set()).add(atom);
+        }
+        if (!unwrap) return anotherAtom.state;
+        if (anotherAtom.state.promise)
+          throw new Wrapped(anotherAtom.state.promise);
+        if (anotherAtom.state.error)
+          throw new Wrapped(anotherAtom.state.error);
+        return anotherAtom.state.value;
+      },
+      atom.l
+    );
+    if (isPromiseLike(value)) {
+      atom.state.promise = value;
+      value.then(
+        (value2) => {
+          if (counter === atom.g) {
+            if (equals(value2, atom.state.value, atom.m)) {
+              atom.state.promise = void 0;
+            } else {
+              atom.f = value2;
+              atom.n = void 0;
+              requestPropagate(atom);
+            }
+          }
+        },
+        (error) => {
+          if (counter === atom.g) {
+            if (error instanceof Promise) {
+              atom.state.promise = void 0;
+            } else {
+              atom.n = error;
+              requestPropagate(atom);
+            }
+          }
+        }
+      );
+    } else {
+      ++atom.g;
+      atom.state.error = void 0;
+      if (equals(value, atom.state.value, atom.m)) {
+        atom.b = false;
+      } else {
+        atom.state.value = atom.f = value;
+      }
+    }
+  } catch (e) {
+    ++atom.g;
+    if (!e) {
+      atom.b = false;
+    } else {
+      if (e instanceof Wrapped) {
+        e = e.e;
+      } else {
+        console.error(e);
+      }
+      if (isPromiseLike(e)) {
+        atom.state.promise = e;
+      } else {
+        atom.state.error = e;
+      }
+    }
+  }
+  if (oldDependencies) {
+    for (const dep of oldDependencies) {
+      dep.d.delete(atom);
+      disableAtom(dep);
+    }
+  }
+};
+let disabling = false;
+const disableAtom = (atom) => {
+  if (!atom.o && !atom.s && !atom.d?.size && !atom.h?.size && !atom.i?.size) {
+    if (!disabling) {
+      setTimeout(() => {
+        disabling = true;
+        disableAtom(atom);
+        disabling = false;
+      }, 0);
+      return;
+    }
+    atom.state.promise = inactive;
+    atom.f = atom.n = atom.state.error = atom.state.value = void 0;
+    atom.b = atom.j = atom.c = false;
+    if (atom.a) {
+      atom.a.abort();
+      atom.a = void 0;
+    }
+    if (atom.k) {
+      for (const dep of atom.k) {
+        dep.d.delete(atom);
+        disableAtom(dep);
+      }
+      atom.k.clear();
+    }
+  }
+};
+const equals = (value, prevValue, equalsFn) => Object.is(value, prevValue) || equalsFn !== void 0 && prevValue !== void 0 && equalsFn(value, prevValue);
+const isPromiseLike = (x) => typeof x?.then === "function";
+const createThenableSignal = () => {
+  const ctrl = new AbortController();
+  const signal = ctrl.signal;
+  const promise = new Promise((resolve) => {
+    signal.then = (f) => promise.then(f);
+    signal.addEventListener("abort", resolve, {
+      once: true,
+      passive: true
+    });
+  });
+  return {
+    abort: () => ctrl.abort(),
+    signal
+  };
+};
+export {
+  $,
+  $$,
+  inactive
+};

package/dist/react.d.ts

@@ -0,0 +1,6 @@
+import type { Atom, DerivedAtom, PrimitiveAtom } from '.';
+export * from '.';
+export declare const useAtom: <Value>(atom: PrimitiveAtom<Value>) => readonly [Value, (value: import(".").AtomUpdater<Value>) => void];
+export declare const useAtomValue: <Value>(atom: Atom<Value>) => Value;
+export declare const useAtomState: <Value>(atom: DerivedAtom<Value>) => import(".").AtomState<Value>;
+export declare const useStateAtom: <Value>(atom: PrimitiveAtom<Value>) => readonly [Value, (newState: Value) => void];

package/dist/react.js

@@ -0,0 +1,25 @@
+import { useState, useSyncExternalStore } from "react";
+export * from ".";
+const useAtom = (atom) => [useSyncExternalStore(atom.watch, atom.get), atom.set];
+const useAtomValue = (atom) => useSyncExternalStore(atom.watch, atom.get);
+const useAtomState = (atom) => useSyncExternalStore(atom.watch, () => {
+  try {
+    atom.get();
+  } catch (_) {
+  }
+  return atom.state;
+});
+const useStateAtom = (atom) => {
+  const [state, setState] = useState(() => atom.get());
+  const setStateWithAtom = (newState) => {
+    setState(newState);
+    atom.set(newState);
+  };
+  return [state, setStateWithAtom];
+};
+export {
+  useAtom,
+  useAtomState,
+  useAtomValue,
+  useStateAtom
+};

package/package.json

@@ -1,14 +1,43 @@
 {
   "name": "bansa",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "",
   "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "react": {
+        "types": "./dist/react.d.ts",
+        "default": "./dist/react.js"
+      },
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
   "devDependencies": {
     "@biomejs/biome": "2.0.0-beta.6",
     "@types/react": "^19.1.8",
     "@types/react-dom": "^19.1.6",
+    "esbuild": "^0.25.5",
+    "typescript": "^5.8.3",
     "vitest": "^3.1.4"
   },
+  "peerDependencies": {
+    "@types/react": ">=17.0.0",
+    "react": ">=17.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
   "author": "cgiosy",
   "license": "MIT",
   "repository": {
@@ -25,6 +54,11 @@
     "react"
   ],
   "scripts": {
+    "build": "pnpm run \"/^build:.*/\"",
+    "build:types": "tsc --noEmit false --emitDeclarationOnly --outDir dist",
+    "build:index": "esbuild src/index.ts --mangle-props=^_ --format=esm --target=es2022 --outfile=dist/index.js",
+    "build:index-browser": "esbuild src/index.ts --mangle-props=^_ --minify --bundle --format=esm --target=es2022 --platform=browser --outfile=dist/index.browser.js",
+    "build:react": "esbuild src/react.tsx --mangle-props=^_ --format=esm --target=es2022 --outfile=dist/react.js",
     "test": "vitest",
     "format": "biome format --write ./src"
   }

package/src/react.tsx

@@ -1,6 +1,8 @@
 import { useState, useSyncExternalStore } from 'react';
 import type { Atom, DerivedAtom, PrimitiveAtom } from '.';
 
+export * from '.';
+
 export const useAtom = <Value,>(atom: PrimitiveAtom<Value>) =>
 	[useSyncExternalStore(atom.watch, atom.get), atom.set] as const;
 

package/tsconfig.json

@@ -6,6 +6,7 @@
     "module": "ESNext",
     "skipLibCheck": true,
     "useDefineForClassFields": true,
+    "declaration": true,
 
     /* Bundler mode */
     "moduleResolution": "bundler",

package/biome.json

@@ -1,39 +0,0 @@
-{
-	"files": {
-		"maxSize": 16777216,
-		"ignoreUnknown": true
-	},
-	"formatter": {
-		"enabled": true,
-		"lineWidth": 80,
-		"indentStyle": "tab",
-		"indentWidth": 4
-	},
-	"javascript": {
-		"formatter": {
-			"quoteStyle": "single"
-		}
-	},
-	"linter": {
-		"rules": {
-			"correctness": {
-				"noConstantCondition": "off",
-				"noEmptyCharacterClassInRegex": "off"
-			},
-			"security": {
-				"noDangerouslySetInnerHtml": "off"
-			},
-			"style": {
-				"noParameterAssign": "off",
-				"noNonNullAssertion": "off"
-			},
-			"suspicious": {
-				"noAssignInExpressions": "off",
-				"noCatchAssign": "off",
-				"noConfusingLabels": "off",
-				"noExplicitAny": "off",
-				"noThenProperty": "off"
-			}
-		}
-	}
-}