bunja 0.0.11 → 0.1.0

package/dist/bunja-QjknYXY-.cjs

@@ -0,0 +1,186 @@
+"use strict";
+
+//#region bunja.ts
+const bunjaEffectSymbol = Symbol("Bunja.effect");
+var Bunja = class Bunja {
+	static bunjas = [];
+	id;
+	debugLabel = "";
+	constructor(deps, parents, relatedBunjas, relatedScopes, init) {
+		this.deps = deps;
+		this.parents = parents;
+		this.relatedBunjas = relatedBunjas;
+		this.relatedScopes = relatedScopes;
+		this.init = init;
+		this.id = Bunja.bunjas.length;
+		Bunja.bunjas.push(this);
+	}
+	static effect = bunjaEffectSymbol;
+	toString() {
+		const { id, debugLabel } = this;
+		return `[Bunja:${id}${debugLabel && ` - ${debugLabel}`}]`;
+	}
+};
+var Scope = class Scope {
+	static scopes = [];
+	id;
+	debugLabel = "";
+	constructor() {
+		this.id = Scope.scopes.length;
+		Scope.scopes.push(this);
+	}
+	toString() {
+		const { id, debugLabel } = this;
+		return `[Scope:${id}${debugLabel && ` - ${debugLabel}`}]`;
+	}
+};
+var BunjaStore = class {
+	#bunjas = {};
+	#scopes = new Map();
+	get(bunja$1, readScope) {
+		const scopeInstanceMap = new Map(bunja$1.relatedScopes.map((scope) => [scope, this.#getScopeInstance(scope, readScope(scope))]));
+		const bunjaInstance = this.#getBunjaInstance(bunja$1, scopeInstanceMap);
+		const { relatedBunjaInstanceMap } = bunjaInstance;
+		return {
+			value: bunjaInstance.value,
+			mount() {
+				relatedBunjaInstanceMap.forEach((related) => related.add());
+				bunjaInstance.add();
+				scopeInstanceMap.forEach((scope) => scope.add());
+				return function unmount() {
+					relatedBunjaInstanceMap.forEach((related) => related.sub());
+					bunjaInstance.sub();
+					scopeInstanceMap.forEach((scope) => scope.sub());
+				};
+			},
+			deps: Array.from(scopeInstanceMap.values()).map(({ value }) => value)
+		};
+	}
+	#getBunjaInstance(bunja$1, scopeInstanceMap) {
+		const localScopeInstanceMap = new Map(bunja$1.relatedScopes.map((scope) => [scope, scopeInstanceMap.get(scope)]));
+		const scopeInstanceIds = Array.from(localScopeInstanceMap.values()).map(({ instanceId }) => instanceId).sort((a, b) => a - b);
+		const bunjaInstanceId = `${bunja$1.id}:${scopeInstanceIds.join(",")}`;
+		if (this.#bunjas[bunjaInstanceId]) return this.#bunjas[bunjaInstanceId];
+		const relatedBunjaInstanceMap = new Map(bunja$1.relatedBunjas.map((relatedBunja) => [relatedBunja, this.#getBunjaInstance(relatedBunja, scopeInstanceMap)]));
+		const args = bunja$1.deps.map((dep) => {
+			if (dep instanceof Bunja) return relatedBunjaInstanceMap.get(dep).value;
+			if (dep instanceof Scope) return localScopeInstanceMap.get(dep).value;
+			throw new Error("Invalid dependency");
+		});
+		const bunjaInstance = new BunjaInstance(() => delete this.#bunjas[bunjaInstanceId], bunjaInstanceId, relatedBunjaInstanceMap, bunja$1.init.apply(bunja$1, args));
+		this.#bunjas[bunjaInstanceId] = bunjaInstance;
+		return bunjaInstance;
+	}
+	#getScopeInstance(scope, value) {
+		const scopeInstanceMap = this.#scopes.get(scope) ?? this.#scopes.set(scope, new Map()).get(scope);
+		const init = () => new ScopeInstance(() => scopeInstanceMap.delete(value), ScopeInstance.counter++, scope, value);
+		return scopeInstanceMap.get(value) ?? scopeInstanceMap.set(value, init()).get(value);
+	}
+};
+const createBunjaStore = () => new BunjaStore();
+function bunjaImpl(deps, init) {
+	const parents = deps.filter((dep) => dep instanceof Bunja);
+	const scopes = deps.filter((dep) => dep instanceof Scope);
+	const relatedBunjas = toposort(parents);
+	const relatedScopes = Array.from(new Set([...scopes, ...parents.flatMap((parent) => parent.relatedScopes)]));
+	return new Bunja(deps, parents, relatedBunjas, relatedScopes, init);
+}
+bunjaImpl.effect = Bunja.effect;
+const bunja = bunjaImpl;
+function createScope() {
+	return new Scope();
+}
+var RefCounter = class {
+	#disposed = false;
+	#count = 0;
+	add() {
+		this.#count++;
+	}
+	sub() {
+		this.#count--;
+		setTimeout(() => {
+			if (this.#disposed) return;
+			if (this.#count < 1) {
+				this.#disposed = true;
+				this.dispose();
+			}
+		});
+	}
+};
+const noop = () => {};
+var BunjaInstance = class extends RefCounter {
+	#cleanup;
+	#dispose;
+	constructor(dispose, instanceId, relatedBunjaInstanceMap, value) {
+		super();
+		this.instanceId = instanceId;
+		this.relatedBunjaInstanceMap = relatedBunjaInstanceMap;
+		this.value = value;
+		this.#dispose = () => {
+			this.#cleanup?.();
+			dispose();
+		};
+	}
+	add() {
+		this.#cleanup ??= this.value[Bunja.effect]?.() ?? noop;
+		super.add();
+	}
+	dispose() {
+		this.#dispose();
+	}
+};
+var ScopeInstance = class extends RefCounter {
+	static counter = 0;
+	constructor(dispose, instanceId, scope, value) {
+		super();
+		this.dispose = dispose;
+		this.instanceId = instanceId;
+		this.scope = scope;
+		this.value = value;
+	}
+};
+function toposort(nodes) {
+	const visited = new Set();
+	const result = [];
+	function visit(current) {
+		if (visited.has(current)) return;
+		visited.add(current);
+		for (const parent of current.parents) visit(parent);
+		result.push(current);
+	}
+	for (const node of nodes) visit(node);
+	return result;
+}
+
+//#endregion
+Object.defineProperty(exports, 'Bunja', {
+  enumerable: true,
+  get: function () {
+    return Bunja;
+  }
+});Object.defineProperty(exports, 'BunjaStore', {
+  enumerable: true,
+  get: function () {
+    return BunjaStore;
+  }
+});Object.defineProperty(exports, 'Scope', {
+  enumerable: true,
+  get: function () {
+    return Scope;
+  }
+});Object.defineProperty(exports, 'bunja', {
+  enumerable: true,
+  get: function () {
+    return bunja;
+  }
+});Object.defineProperty(exports, 'createBunjaStore', {
+  enumerable: true,
+  get: function () {
+    return createBunjaStore;
+  }
+});Object.defineProperty(exports, 'createScope', {
+  enumerable: true,
+  get: function () {
+    return createScope;
+  }
+});

package/dist/bunja.cjs

@@ -0,0 +1,9 @@
+"use strict";
+const require_bunja = require('./bunja-QjknYXY-.cjs');
+
+exports.Bunja = require_bunja.Bunja
+exports.BunjaStore = require_bunja.BunjaStore
+exports.Scope = require_bunja.Scope
+exports.bunja = require_bunja.bunja
+exports.createBunjaStore = require_bunja.createBunjaStore
+exports.createScope = require_bunja.createScope

package/dist/bunja.d.cts

@@ -0,0 +1,53 @@
+export type Dep<T> = Bunja<T> | Scope<T>;
+declare const bunjaEffectSymbol: unique symbol;
+type BunjaEffectSymbol = typeof bunjaEffectSymbol;
+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;
+    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;
+    toString(): string;
+}
+export declare class Scope<T> {
+    static readonly scopes: Scope<any>[];
+    readonly id: number;
+    debugLabel: string;
+    constructor();
+    toString(): string;
+}
+export type ReadScope = <T>(scope: Scope<T>) => T;
+export declare class BunjaStore {
+    #private;
+    get<T>(bunja: Bunja<T>, readScope: ReadScope): {
+        value: T;
+        mount: () => void;
+        deps: any[];
+    };
+}
+export declare const createBunjaStore: () => BunjaStore;
+export type BunjaEffectFn = () => () => void;
+export interface BunjaValue {
+    [Bunja.effect]?: BunjaEffectFn;
+}
+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>(): Scope<T>;
+export {};

package/dist/bunja.d.ts

@@ -0,0 +1,53 @@
+export type Dep<T> = Bunja<T> | Scope<T>;
+declare const bunjaEffectSymbol: unique symbol;
+type BunjaEffectSymbol = typeof bunjaEffectSymbol;
+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;
+    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;
+    toString(): string;
+}
+export declare class Scope<T> {
+    static readonly scopes: Scope<any>[];
+    readonly id: number;
+    debugLabel: string;
+    constructor();
+    toString(): string;
+}
+export type ReadScope = <T>(scope: Scope<T>) => T;
+export declare class BunjaStore {
+    #private;
+    get<T>(bunja: Bunja<T>, readScope: ReadScope): {
+        value: T;
+        mount: () => void;
+        deps: any[];
+    };
+}
+export declare const createBunjaStore: () => BunjaStore;
+export type BunjaEffectFn = () => () => void;
+export interface BunjaValue {
+    [Bunja.effect]?: BunjaEffectFn;
+}
+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>(): Scope<T>;
+export {};

package/dist/bunja.js

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

package/dist/react.cjs

@@ -0,0 +1,65 @@
+"use strict";
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const require_bunja = require('./bunja-QjknYXY-.cjs');
+const { createContext, useContext, useEffect } = __toESM(require("react"));
+
+//#region react.ts
+const BunjaStoreContext = createContext(require_bunja.createBunjaStore());
+const scopeContextMap = new Map();
+function bindScope(scope, context) {
+	scopeContextMap.set(scope, context);
+}
+function createScopeFromContext(context) {
+	const scope = require_bunja.createScope();
+	bindScope(scope, context);
+	return scope;
+}
+const defaultReadScope = (scope) => {
+	const context = scopeContextMap.get(scope);
+	return useContext(context);
+};
+function useBunja(bunja, readScope = defaultReadScope) {
+	const store = useContext(BunjaStoreContext);
+	const { value, mount, deps } = store.get(bunja, readScope);
+	useEffect(mount, deps);
+	return value;
+}
+function inject(overrideTable) {
+	const map = new Map(overrideTable);
+	return (scope) => {
+		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);
+	};
+}
+
+//#endregion
+exports.BunjaStoreContext = BunjaStoreContext
+exports.bindScope = bindScope
+exports.createScopeFromContext = createScopeFromContext
+exports.inject = inject
+exports.scopeContextMap = scopeContextMap
+exports.useBunja = useBunja

package/dist/react.d.cts

@@ -0,0 +1,9 @@
+import { type Context } from "react";
+import { type Bunja, type BunjaStore, 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 createScopeFromContext<T>(context: Context<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;

package/dist/react.d.ts

@@ -0,0 +1,9 @@
+import { type Context } from "react";
+import { type Bunja, type BunjaStore, 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 createScopeFromContext<T>(context: Context<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;

package/dist/react.js

@@ -0,0 +1,36 @@
+import { createBunjaStore, createScope } from "./bunja-3B0nQ1vI.js";
+import { createContext, useContext, useEffect } from "react";
+
+//#region react.ts
+const BunjaStoreContext = createContext(createBunjaStore());
+const scopeContextMap = new Map();
+function bindScope(scope, context) {
+	scopeContextMap.set(scope, context);
+}
+function createScopeFromContext(context) {
+	const scope = createScope();
+	bindScope(scope, context);
+	return scope;
+}
+const defaultReadScope = (scope) => {
+	const context = scopeContextMap.get(scope);
+	return useContext(context);
+};
+function useBunja(bunja, readScope = defaultReadScope) {
+	const store = useContext(BunjaStoreContext);
+	const { value, mount, deps } = store.get(bunja, readScope);
+	useEffect(mount, deps);
+	return value;
+}
+function inject(overrideTable) {
+	const map = new Map(overrideTable);
+	return (scope) => {
+		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);
+	};
+}
+
+//#endregion
+export { BunjaStoreContext, bindScope, createScopeFromContext, inject, scopeContextMap, useBunja };

package/package.json

@@ -1,9 +1,47 @@
 {
   "name": "bunja",
-  "version": "0.0.11",
+  "type": "module",
+  "version": "0.1.0",
   "description": "State Lifetime Manager",
-  "main": "bunja.ts",
-  "scripts": {},
+  "main": "dist/bunja.cjs",
+  "module": "dist/bunja.js",
+  "types": "dist/bunja.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/bunja.d.ts",
+        "default": "./dist/bunja.js"
+      },
+      "require": {
+        "types": "./dist/bunja.d.cts",
+        "default": "./dist/bunja.cjs"
+      }
+    },
+    "./react": {
+      "import": {
+        "types": "./dist/react.d.ts",
+        "default": "./dist/react.js"
+      },
+      "require": {
+        "types": "./dist/react.d.cts",
+        "default": "./dist/react.cjs"
+      }
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "react": [
+        "./dist/react.d.ts"
+      ],
+      "*": [
+        "./dist/bunja.d.ts"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "check": "tsc --noEmit"
+  },
   "keywords": [
     "bunja",
     "di"
@@ -12,7 +50,9 @@
   "license": "Zlib",
   "devDependencies": {
     "@types/react": "^18",
-    "react": "^18"
+    "react": "^18",
+    "tsdown": "^0.2.17",
+    "typescript": "^5.6.3"
   },
   "peerDependencies": {
     "@types/react": "*",

package/react.ts

@@ -1,16 +1,18 @@
-import { Context, createContext, useContext, useEffect } from "react";
+import { type Context, createContext, useContext, useEffect } from "react";
 import {
-  Bunja,
+  type Bunja,
+  type BunjaStore,
   createBunjaStore,
   createScope,
-  ReadScope,
-  Scope,
-} from "./bunja";
+  type ReadScope,
+  type Scope,
+} from "./bunja.ts";
 
-export const BunjaStoreContext = createContext(createBunjaStore());
+export const BunjaStoreContext: Context<BunjaStore> =
+  createContext(createBunjaStore());
 
-export const scopeContextMap = new Map<Scope<any>, Context<any>>();
-export function bindScope(scope: Scope<any>, context: Context<any>) {
+export const scopeContextMap: Map<Scope<any>, Context<any>> = new Map();
+export function bindScope(scope: Scope<any>, context: Context<any>): void {
   scopeContextMap.set(scope, context);
 }
 
@@ -25,17 +27,20 @@ const defaultReadScope: ReadScope = (scope) => {
   return useContext(context);
 };
 
-export function useBunja<T>(bunja: Bunja<T>, readScope = defaultReadScope): T {
+export function useBunja<T>(
+  bunja: Bunja<T>,
+  readScope: ReadScope = defaultReadScope,
+): T {
   const store = useContext(BunjaStoreContext);
-  const { value, mount } = store.get(bunja, readScope);
-  useEffect(mount, []);
+  const { value, mount, deps } = store.get(bunja, readScope);
+  useEffect(mount, deps);
   return value;
 }
 
 export type ScopePair<T> = [Scope<T>, T];
 
 export function inject<const T extends ScopePair<any>[]>(
-  overrideTable: T
+  overrideTable: T,
 ): ReadScope {
   const map = new Map(overrideTable);
   return (scope) => {
@@ -43,7 +48,7 @@ export function inject<const T extends ScopePair<any>[]>(
     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."
+        "Unable to read the scope. Please inject the value explicitly or bind scope to the React context.",
       );
     }
     return useContext(context);

package/tsconfig.json

@@ -2,6 +2,12 @@
   "compilerOptions": {
     "target": "ESNext",
     "strict": true,
-    "moduleResolution": "Node"
+    "moduleResolution": "Bundler",
+    "allowImportingTsExtensions": true,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "isolatedDeclarations": true,
+    "skipLibCheck": true,
+    "outDir": "dist"
   }
 }

package/tsdown.config.ts

@@ -0,0 +1,10 @@
+import type { Options } from "tsdown";
+
+const config: Options = {
+  entry: ["bunja.ts", "react.ts"],
+  clean: true,
+  dts: true,
+  format: ["esm", "cjs"],
+};
+
+export default config;