bunja 1.0.0 → 2.0.0-alpha.2

package/dist/bunja.d.ts

@@ -1,55 +1,64 @@
+export interface BunjaFn {
+    <T>(init: () => T): Bunja<T>;
+    use: BunjaUseFn;
+    effect: BunjaEffectFn;
+}
+export declare const bunja: BunjaFn;
+export type BunjaUseFn = <T>(dep: Dep<T>) => T;
+export type BunjaEffectFn = (callback: BunjaEffectCallback) => void;
+export type BunjaEffectCallback = () => (() => void) | void;
+export declare function createScope<T>(hash?: HashFn<T>): Scope<T>;
+export declare function createBunjaStore(): BunjaStore;
 export type Dep<T> = Bunja<T> | Scope<T>;
-declare const bunjaEffectSymbol: unique symbol;
-type BunjaEffectSymbol = typeof bunjaEffectSymbol;
+export declare class BunjaStore {
+    #private;
+    dispose(): void;
+    get<T>(bunja: Bunja<T>, readScope: ReadScope): BunjaStoreGetResult<T>;
+}
+export type ReadScope = <T>(scope: Scope<T>) => T;
+export interface BunjaStoreGetResult<T> {
+    value: T;
+    mount: () => () => void;
+    deps: unknown[];
+}
 export declare class Bunja<T> {
-    deps: Dep<any>[];
-    parents: Bunja<any>[];
-    relatedBunjas: Bunja<any>[];
-    relatedScopes: Scope<any>[];
-    init: (...args: any[]) => T & BunjaValue;
-    static readonly bunjas: Bunja<any>[];
-    readonly id: number;
+    #private;
+    init: () => T;
+    private static counter;
+    readonly id: string;
     debugLabel: string;
-    constructor(deps: Dep<any>[], // one depth dependencies
-    parents: Bunja<any>[], // one depth parents
-    relatedBunjas: Bunja<any>[], // toposorted parents without self
-    relatedScopes: Scope<any>[], // deduped
-    init: (...args: any[]) => T & BunjaValue);
-    static readonly effect: BunjaEffectSymbol;
+    constructor(init: () => T);
+    get baked(): boolean;
+    get parents(): Bunja<unknown>[];
+    get relatedBunjas(): Bunja<unknown>[];
+    get relatedScopes(): Scope<unknown>[];
+    addParent(bunja: Bunja<unknown>): void;
+    addScope(scope: Scope<unknown>): void;
+    bake(): void;
+    calcInstanceId(scopeInstanceMap: Map<Scope<unknown>, ScopeInstance>): string;
     toString(): string;
 }
-export type HashFn<T = any, U = any> = (value: T) => U;
 export declare class Scope<T> {
-    readonly hash: HashFn;
-    static readonly scopes: Scope<any>[];
-    readonly id: number;
+    readonly hash: HashFn<T>;
+    private static counter;
+    readonly id: string;
     debugLabel: string;
-    constructor(hash?: HashFn);
+    constructor(hash?: HashFn<T>);
+    private static identity;
     toString(): string;
 }
-export type ReadScope = <T>(scope: Scope<T>) => T;
-export declare class BunjaStore {
+export type HashFn<T> = (value: T) => unknown;
+declare abstract class RefCounter {
     #private;
-    get<T>(bunja: Bunja<T>, readScope: ReadScope): {
-        value: T;
-        mount: () => () => void;
-        deps: any[];
-    };
+    abstract dispose(): void;
+    add(): void;
+    sub(): void;
 }
-export declare const createBunjaStore: () => BunjaStore;
-export type BunjaEffectFn = () => () => void;
-export interface BunjaValue {
-    [Bunja.effect]?: BunjaEffectFn;
+declare class ScopeInstance extends RefCounter {
+    readonly value: unknown;
+    readonly dispose: () => void;
+    private static counter;
+    readonly id: string;
+    constructor(value: unknown, dispose: () => void);
 }
-export declare const bunja: {
-    <T>(deps: [], init: () => T & BunjaValue): Bunja<T>;
-    <T, U>(deps: [Dep<U>], init: (u: U) => T & BunjaValue): Bunja<T>;
-    <T, U, V>(deps: [Dep<U>, Dep<V>], init: (u: U, v: V) => T & BunjaValue): Bunja<T>;
-    <T, U, V, W>(deps: [Dep<U>, Dep<V>, Dep<W>], init: (u: U, v: V, w: W) => T & BunjaValue): Bunja<T>;
-    <T, U, V, W, X>(deps: [Dep<U>, Dep<V>, Dep<W>, Dep<X>], init: (u: U, v: V, w: W, x: X) => T & BunjaValue): Bunja<T>;
-    <T, U, V, W, X, Y>(deps: [Dep<U>, Dep<V>, Dep<W>, Dep<X>, Dep<Y>], init: (u: U, v: V, w: W, x: X, y: Y) => T & BunjaValue): Bunja<T>;
-    <T, U, V, W, X, Y, Z>(deps: [Dep<U>, Dep<V>, Dep<W>, Dep<X>, Dep<Y>, Dep<Z>], init: (u: U, v: V, w: W, x: X, y: Y, z: Z) => T & BunjaValue): Bunja<T>;
-    readonly effect: BunjaEffectSymbol;
-};
-export declare function createScope<T>(hash?: HashFn): Scope<T>;
 export {};

package/dist/bunja.js

@@ -1,3 +1,3 @@
-import { Bunja, BunjaStore, Scope, bunja, createBunjaStore, createScope } from "./bunja-fHIhQAuL.js";
+import { Bunja, BunjaStore, Scope, bunja, createBunjaStore, createScope } from "./bunja-wcx846sL.js";
 
 export { Bunja, BunjaStore, Scope, bunja, createBunjaStore, createScope };

package/dist/react.cjs

@@ -22,11 +22,19 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const require_bunja = require('./bunja-Q0ZusYIM.cjs');
-const { createContext, useContext, useEffect } = __toESM(require("react"));
+const require_bunja = require('./bunja-bUA1rGXy.cjs');
+const { createContext, createElement, use, useEffect, useState } = __toESM(require("react"));
 
 //#region react.ts
 const BunjaStoreContext = createContext(require_bunja.createBunjaStore());
+function BunjaStoreProvider({ children }) {
+	const [value] = useState(require_bunja.createBunjaStore);
+	useEffect(() => () => value.dispose(), [value]);
+	return createElement(BunjaStoreContext, {
+		value,
+		children
+	});
+}
 const scopeContextMap = new Map();
 function bindScope(scope, context) {
 	scopeContextMap.set(scope, context);
@@ -38,10 +46,10 @@ function createScopeFromContext(context, hash) {
 }
 const defaultReadScope = (scope) => {
 	const context = scopeContextMap.get(scope);
-	return useContext(context);
+	return use(context);
 };
 function useBunja(bunja, readScope = defaultReadScope) {
-	const store = useContext(BunjaStoreContext);
+	const store = use(BunjaStoreContext);
 	const { value, mount, deps } = store.get(bunja, readScope);
 	useEffect(mount, deps);
 	return value;
@@ -52,12 +60,13 @@ function inject(overrideTable) {
 		if (map.has(scope)) return map.get(scope);
 		const context = scopeContextMap.get(scope);
 		if (!context) throw new Error("Unable to read the scope. Please inject the value explicitly or bind scope to the React context.");
-		return useContext(context);
+		return use(context);
 	};
 }
 
 //#endregion
 exports.BunjaStoreContext = BunjaStoreContext
+exports.BunjaStoreProvider = BunjaStoreProvider
 exports.bindScope = bindScope
 exports.createScopeFromContext = createScopeFromContext
 exports.inject = inject

package/dist/react.d.cts

@@ -1,9 +1,10 @@
-import { type Context } from "react";
+import { type Context, type PropsWithChildren } from "react";
 import { type Bunja, type BunjaStore, type HashFn, type ReadScope, type Scope } from "./bunja.ts";
 export declare const BunjaStoreContext: Context<BunjaStore>;
-export declare const scopeContextMap: Map<Scope<any>, Context<any>>;
-export declare function bindScope(scope: Scope<any>, context: Context<any>): void;
+export declare function BunjaStoreProvider({ children }: PropsWithChildren): React.JSX.Element;
+export declare const scopeContextMap: Map<Scope<unknown>, Context<unknown>>;
+export declare function bindScope<T>(scope: Scope<T>, context: Context<T>): void;
 export declare function createScopeFromContext<T>(context: Context<T>, hash?: HashFn<T>): Scope<T>;
 export declare function useBunja<T>(bunja: Bunja<T>, readScope?: ReadScope): T;
 export type ScopePair<T> = [Scope<T>, T];
-export declare function inject<const T extends ScopePair<any>[]>(overrideTable: T): ReadScope;
+export declare function inject<const T extends ScopePair<unknown>[]>(overrideTable: T): ReadScope;

package/dist/react.d.ts

@@ -1,9 +1,10 @@
-import { type Context } from "react";
+import { type Context, type PropsWithChildren } from "react";
 import { type Bunja, type BunjaStore, type HashFn, type ReadScope, type Scope } from "./bunja.ts";
 export declare const BunjaStoreContext: Context<BunjaStore>;
-export declare const scopeContextMap: Map<Scope<any>, Context<any>>;
-export declare function bindScope(scope: Scope<any>, context: Context<any>): void;
+export declare function BunjaStoreProvider({ children }: PropsWithChildren): React.JSX.Element;
+export declare const scopeContextMap: Map<Scope<unknown>, Context<unknown>>;
+export declare function bindScope<T>(scope: Scope<T>, context: Context<T>): void;
 export declare function createScopeFromContext<T>(context: Context<T>, hash?: HashFn<T>): Scope<T>;
 export declare function useBunja<T>(bunja: Bunja<T>, readScope?: ReadScope): T;
 export type ScopePair<T> = [Scope<T>, T];
-export declare function inject<const T extends ScopePair<any>[]>(overrideTable: T): ReadScope;
+export declare function inject<const T extends ScopePair<unknown>[]>(overrideTable: T): ReadScope;

package/dist/react.js

@@ -1,8 +1,16 @@
-import { createBunjaStore, createScope } from "./bunja-fHIhQAuL.js";
-import { createContext, useContext, useEffect } from "react";
+import { createBunjaStore, createScope } from "./bunja-wcx846sL.js";
+import { createContext, createElement, use, useEffect, useState } from "react";
 
 //#region react.ts
 const BunjaStoreContext = createContext(createBunjaStore());
+function BunjaStoreProvider({ children }) {
+	const [value] = useState(createBunjaStore);
+	useEffect(() => () => value.dispose(), [value]);
+	return createElement(BunjaStoreContext, {
+		value,
+		children
+	});
+}
 const scopeContextMap = new Map();
 function bindScope(scope, context) {
 	scopeContextMap.set(scope, context);
@@ -14,10 +22,10 @@ function createScopeFromContext(context, hash) {
 }
 const defaultReadScope = (scope) => {
 	const context = scopeContextMap.get(scope);
-	return useContext(context);
+	return use(context);
 };
 function useBunja(bunja, readScope = defaultReadScope) {
-	const store = useContext(BunjaStoreContext);
+	const store = use(BunjaStoreContext);
 	const { value, mount, deps } = store.get(bunja, readScope);
 	useEffect(mount, deps);
 	return value;
@@ -28,9 +36,9 @@ function inject(overrideTable) {
 		if (map.has(scope)) return map.get(scope);
 		const context = scopeContextMap.get(scope);
 		if (!context) throw new Error("Unable to read the scope. Please inject the value explicitly or bind scope to the React context.");
-		return useContext(context);
+		return use(context);
 	};
 }
 
 //#endregion
-export { BunjaStoreContext, bindScope, createScopeFromContext, inject, scopeContextMap, useBunja };
+export { BunjaStoreContext, BunjaStoreProvider, bindScope, createScopeFromContext, inject, scopeContextMap, useBunja };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bunja",
   "type": "module",
-  "version": "1.0.0",
+  "version": "2.0.0-alpha.2",
   "description": "State Lifetime Manager",
   "main": "dist/bunja.cjs",
   "module": "dist/bunja.js",
@@ -49,14 +49,14 @@
   "author": "JongChan Choi <jong@chan.moe>",
   "license": "Zlib",
   "devDependencies": {
-    "@types/react": "^18",
-    "react": "^18",
+    "@types/react": "^19",
+    "react": "^19",
     "tsdown": "^0.2.17",
     "typescript": "^5.6.3"
   },
   "peerDependencies": {
     "@types/react": "*",
-    "react": ">=17"
+    "react": ">=19"
   },
   "peerDependenciesMeta": {
     "@types/react": {

package/react.ts

@@ -1,4 +1,12 @@
-import { type Context, createContext, useContext, useEffect } from "react";
+import {
+  type Context,
+  createContext,
+  createElement,
+  type PropsWithChildren,
+  use,
+  useEffect,
+  useState,
+} from "react";
 import {
   type Bunja,
   type BunjaStore,
@@ -13,30 +21,38 @@ export const BunjaStoreContext: Context<BunjaStore> = createContext(
   createBunjaStore(),
 );
 
-export const scopeContextMap: Map<Scope<any>, Context<any>> = new Map();
-export function bindScope(scope: Scope<any>, context: Context<any>): void {
-  scopeContextMap.set(scope, context);
+export function BunjaStoreProvider(
+  { children }: PropsWithChildren,
+): React.JSX.Element {
+  const [value] = useState(createBunjaStore);
+  useEffect(() => () => value.dispose(), [value]);
+  return createElement(BunjaStoreContext, { value, children });
+}
+
+export const scopeContextMap: Map<Scope<unknown>, Context<unknown>> = new Map();
+export function bindScope<T>(scope: Scope<T>, context: Context<T>): void {
+  scopeContextMap.set(scope as Scope<unknown>, context as Context<unknown>);
 }
 
 export function createScopeFromContext<T>(
   context: Context<T>,
   hash?: HashFn<T>,
 ): Scope<T> {
-  const scope = createScope(hash);
+  const scope = createScope<T>(hash);
   bindScope(scope, context);
   return scope;
 }
 
-const defaultReadScope: ReadScope = (scope) => {
-  const context = scopeContextMap.get(scope)!;
-  return useContext(context);
+const defaultReadScope: ReadScope = <T>(scope: Scope<T>) => {
+  const context = scopeContextMap.get(scope as Scope<unknown>)!;
+  return use(context) as T;
 };
 
 export function useBunja<T>(
   bunja: Bunja<T>,
   readScope: ReadScope = defaultReadScope,
 ): T {
-  const store = useContext(BunjaStoreContext);
+  const store = use(BunjaStoreContext);
   const { value, mount, deps } = store.get(bunja, readScope);
   useEffect(mount, deps);
   return value;
@@ -44,18 +60,20 @@ export function useBunja<T>(
 
 export type ScopePair<T> = [Scope<T>, T];
 
-export function inject<const T extends ScopePair<any>[]>(
+export function inject<const T extends ScopePair<unknown>[]>(
   overrideTable: T,
 ): ReadScope {
   const map = new Map(overrideTable);
-  return (scope) => {
-    if (map.has(scope)) return map.get(scope);
-    const context = scopeContextMap.get(scope);
+  return <T>(scope: Scope<T>) => {
+    if (map.has(scope as Scope<unknown>)) {
+      return map.get(scope as Scope<unknown>) as T;
+    }
+    const context = scopeContextMap.get(scope as Scope<unknown>);
     if (!context) {
       throw new Error(
         "Unable to read the scope. Please inject the value explicitly or bind scope to the React context.",
       );
     }
-    return useContext(context);
+    return use(context) as T;
   };
 }

package/test.ts

@@ -2,10 +2,9 @@ import { assertEquals } from "jsr:@std/assert";
 import { assertSpyCalls, spy } from "jsr:@std/testing/mock";
 import { FakeTime } from "jsr:@std/testing/time";
 
-import { createBunjaStore, createScope } from "./bunja.ts";
-import { bunja } from "./bunja.ts";
+import { bunja, createBunjaStore, createScope } from "./bunja.ts";
 
-const readNull = () => (null as any);
+const readNull = <T>() => (null as T);
 
 Deno.test({
   name: "basic",
@@ -13,7 +12,7 @@ Deno.test({
     using time = new FakeTime();
     const store = createBunjaStore();
     const myBunjaInstance = {};
-    const myBunja = bunja([], () => myBunjaInstance);
+    const myBunja = bunja(() => myBunjaInstance);
     const { value, mount } = store.get(myBunja, readNull);
     const cleanup = mount();
     cleanup();
@@ -29,12 +28,12 @@ Deno.test({
     const store = createBunjaStore();
     const mountSpy = spy();
     const unmountSpy = spy();
-    const myBunja = bunja([], () => ({
-      [bunja.effect]() {
+    const myBunja = bunja(() => {
+      bunja.effect(() => {
         mountSpy();
         return unmountSpy;
-      },
-    }));
+      });
+    });
     assertSpyCalls(mountSpy, 0);
     const { mount } = store.get(myBunja, readNull);
     assertSpyCalls(mountSpy, 0);
@@ -55,20 +54,22 @@ Deno.test({
     const store = createBunjaStore();
     const [aMountSpy, aUnmountSpy] = [spy(), spy()];
     const [bMountSpy, bUnmountSpy] = [spy(), spy()];
-    const aBunjaInstance = {
-      [bunja.effect]() {
+    const aBunjaInstance = {};
+    const aBunja = bunja(() => {
+      bunja.effect(() => {
         aMountSpy();
         return aUnmountSpy;
-      },
-    };
-    const aBunja = bunja([], () => aBunjaInstance);
-    const bBunja = bunja([aBunja], (a) => ({
-      a,
-      [bunja.effect]() {
+      });
+      return aBunjaInstance;
+    });
+    const bBunja = bunja(() => {
+      const a = bunja.use(aBunja);
+      bunja.effect(() => {
         bMountSpy();
         return bUnmountSpy;
-      },
-    }));
+      });
+      return { a };
+    });
     assertSpyCalls(aMountSpy, 0);
     assertSpyCalls(bMountSpy, 0);
     const { value, mount } = store.get(bBunja, readNull);
@@ -96,12 +97,19 @@ Deno.test({
     const store = createBunjaStore();
     const [aMountSpy, aUnmountSpy] = [spy(), spy()];
     const [bMountSpy, bUnmountSpy] = [spy(), spy()];
-    const aBunja = bunja([], () => ({
-      [bunja.effect]: () => (aMountSpy(), aUnmountSpy),
-    }));
-    const bBunja = bunja([aBunja], () => ({
-      [bunja.effect]: () => (bMountSpy(), bUnmountSpy),
-    }));
+    const aBunja = bunja(() => {
+      bunja.effect(() => {
+        aMountSpy();
+        return aUnmountSpy;
+      });
+    });
+    const bBunja = bunja(() => {
+      bunja.use(aBunja);
+      bunja.effect(() => {
+        bMountSpy();
+        return bUnmountSpy;
+      });
+    });
     const { mount: m1 } = store.get(aBunja, readNull);
     const c1 = m1();
     assertSpyCalls(aMountSpy, 1);
@@ -130,12 +138,19 @@ Deno.test({
     const store = createBunjaStore();
     const [aMountSpy, aUnmountSpy] = [spy(), spy()];
     const [bMountSpy, bUnmountSpy] = [spy(), spy()];
-    const aBunja = bunja([], () => ({
-      [bunja.effect]: () => (aMountSpy(), aUnmountSpy),
-    }));
-    const bBunja = bunja([aBunja], () => ({
-      [bunja.effect]: () => (bMountSpy(), bUnmountSpy),
-    }));
+    const aBunja = bunja(() => {
+      bunja.effect(() => {
+        aMountSpy();
+        return aUnmountSpy;
+      });
+    });
+    const bBunja = bunja(() => {
+      bunja.use(aBunja);
+      bunja.effect(() => {
+        bMountSpy();
+        return bUnmountSpy;
+      });
+    });
     const { mount: m1 } = store.get(bBunja, readNull);
     const c1 = m1();
     assertSpyCalls(aMountSpy, 1);
@@ -163,7 +178,10 @@ Deno.test({
     using time = new FakeTime();
     const store = createBunjaStore();
     const myScope = createScope<string>();
-    const myBunja = bunja([myScope], (scopeValue) => ({ scopeValue }));
+    const myBunja = bunja(() => {
+      const scopeValue = bunja.use(myScope);
+      return { scopeValue };
+    });
     const readScope = <T>(): T => "injected value" as T;
     const { value: { scopeValue }, mount } = store.get(myBunja, readScope);
     const cleanup = mount();
@@ -179,7 +197,10 @@ Deno.test({
     using time = new FakeTime();
     const store = createBunjaStore();
     const myScope = createScope<string>(({ length }) => length);
-    const myBunja = bunja([myScope], (scopeValue) => ({ scopeValue }));
+    const myBunja = bunja(() => {
+      const scopeValue = bunja.use(myScope);
+      return { scopeValue };
+    });
     const { value: { scopeValue: scopeValue1 }, mount: mount1 } = store.get(
       myBunja,
       <T>() => "foo" as T,