bunja 2.0.0-alpha.1 → 2.0.0-alpha.3

package/bunja.ts

@@ -94,12 +94,7 @@ export class BunjaStore {
         this.#getScopeInstance(scope, readScope(scope)),
       ]),
     );
-    const bunjaInstanceMap = new Map(
-      bunja.relatedBunjas.map((relatedBunja) => [
-        relatedBunja,
-        this.#getBunjaInstance(relatedBunja, scopeInstanceMap),
-      ]),
-    );
+    const bunjaInstanceMap = new Map();
     bunjaFn.use = <T>(dep: Dep<T>) => {
       if (dep instanceof Bunja) {
         return bunjaInstanceMap.get(dep as Bunja<unknown>)!.value as T;
@@ -109,6 +104,12 @@ export class BunjaStore {
       }
       throw new Error("`bunja.use` can only be used with Bunja or Scope.");
     };
+    for (const relatedBunja of bunja.relatedBunjas) {
+      bunjaInstanceMap.set(
+        relatedBunja,
+        this.#getBunjaInstance(relatedBunja, scopeInstanceMap),
+      );
+    }
     const bunjaInstance = this.#getBunjaInstance(bunja, scopeInstanceMap);
     return { bunjaInstance, bunjaInstanceMap, scopeInstanceMap };
   }

package/codemod/bunja-v1-to-v2.js

@@ -0,0 +1,118 @@
+module.exports = function (fileInfo, api) {
+  const j = api.jscodeshift;
+  const root = j(fileInfo.source);
+  let modified = false;
+
+  root.find(j.CallExpression, { callee: { name: "bunja" } }).forEach((path) => {
+    const { node } = path;
+    const args = node.arguments;
+    if (args.length !== 2) return;
+
+    const [depsArray, initFn] = args;
+    if (depsArray.type !== "ArrayExpression") return;
+    if (
+      initFn.type !== "ArrowFunctionExpression" &&
+      initFn.type !== "FunctionExpression"
+    ) return;
+    const params = initFn.params;
+
+    const bodyStatements = initFn.body.type === "BlockStatement"
+      ? [...initFn.body.body]
+      : [{ type: "ReturnStatement", argument: initFn.body }];
+
+    const useStatements = depsArray.elements.map((dep, index) => {
+      if (index < params.length) {
+        return {
+          type: "VariableDeclaration",
+          kind: "const",
+          declarations: [{
+            type: "VariableDeclarator",
+            id: params[index],
+            init: {
+              type: "CallExpression",
+              callee: {
+                type: "MemberExpression",
+                object: { type: "Identifier", name: "bunja" },
+                property: { type: "Identifier", name: "use" },
+                computed: false,
+              },
+              arguments: [dep],
+            },
+          }],
+        };
+      } else {
+        return {
+          type: "ExpressionStatement",
+          expression: {
+            type: "CallExpression",
+            callee: {
+              type: "MemberExpression",
+              object: { type: "Identifier", name: "bunja" },
+              property: { type: "Identifier", name: "use" },
+              computed: false,
+            },
+            arguments: [dep],
+          },
+        };
+      }
+    });
+
+    for (let i = 0; i < bodyStatements.length; ++i) {
+      const statement = bodyStatements[i];
+      if (!statement || statement.type !== "ReturnStatement") continue;
+      if (statement.argument?.type !== "ObjectExpression") continue;
+      const returnObj = statement.argument;
+      const props = returnObj.properties;
+
+      const effectPropIndex = props.findIndex((prop) =>
+        prop?.computed &&
+        prop.key?.type === "MemberExpression" &&
+        prop.key?.object?.name === "bunja" &&
+        prop.key?.property?.name === "effect"
+      );
+      if (effectPropIndex === -1) continue;
+
+      const prop = props[effectPropIndex];
+      let effectFn = prop.value;
+
+      if (effectFn.type === "FunctionExpression") {
+        effectFn = {
+          type: "ArrowFunctionExpression",
+          params: effectFn.params,
+          body: effectFn.body,
+        };
+      }
+
+      const effectStatement = {
+        type: "ExpressionStatement",
+        expression: {
+          type: "CallExpression",
+          callee: {
+            type: "MemberExpression",
+            object: { type: "Identifier", name: "bunja" },
+            property: { type: "Identifier", name: "effect" },
+            computed: false,
+          },
+          arguments: [effectFn],
+        },
+      };
+
+      props.splice(effectPropIndex, 1);
+      bodyStatements.splice(i, 0, effectStatement);
+      ++i;
+    }
+
+    node.arguments = [{
+      type: "ArrowFunctionExpression",
+      params: [],
+      body: {
+        type: "BlockStatement",
+        body: [...useStatements, ...bodyStatements],
+      },
+    }];
+
+    modified = true;
+  });
+
+  return modified ? root.toSource() : fileInfo.source;
+};

package/compat/bunja-v1.ts

@@ -1,4 +1,5 @@
 import { type Bunja, bunja as bunjaV2, type Dep } from "../bunja.ts";
+export { Bunja, createScope, Scope } from "../bunja.ts";
 
 export const bunja: {
   <T>(deps: [], init: () => T & BunjaValue): Bunja<T>;

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@disjukr/bunja",
-  "version": "2.0.0-alpha.1",
+  "version": "2.0.0-alpha.3",
   "license": "Zlib",
   "exports": {
     ".": "./bunja.ts",

package/dist/{bunja-wcx846sL.js → bunja-DGNjfjPa.js}

@@ -55,12 +55,13 @@ var BunjaStore = class {
 	}
 	#getBaked(bunja$1, readScope) {
 		const scopeInstanceMap = new Map(bunja$1.relatedScopes.map((scope) => [scope, this.#getScopeInstance(scope, readScope(scope))]));
-		const bunjaInstanceMap = new Map(bunja$1.relatedBunjas.map((relatedBunja) => [relatedBunja, this.#getBunjaInstance(relatedBunja, scopeInstanceMap)]));
+		const bunjaInstanceMap = new Map();
 		bunjaFn.use = (dep) => {
 			if (dep instanceof Bunja) return bunjaInstanceMap.get(dep).value;
 			if (dep instanceof Scope) return scopeInstanceMap.get(dep).value;
 			throw new Error("`bunja.use` can only be used with Bunja or Scope.");
 		};
+		for (const relatedBunja of bunja$1.relatedBunjas) bunjaInstanceMap.set(relatedBunja, this.#getBunjaInstance(relatedBunja, scopeInstanceMap));
 		const bunjaInstance = this.#getBunjaInstance(bunja$1, scopeInstanceMap);
 		return {
 			bunjaInstance,

package/dist/{bunja-bUA1rGXy.cjs → bunja-RF4EuS_C.cjs}

@@ -56,12 +56,13 @@ var BunjaStore = class {
 	}
 	#getBaked(bunja$1, readScope) {
 		const scopeInstanceMap = new Map(bunja$1.relatedScopes.map((scope) => [scope, this.#getScopeInstance(scope, readScope(scope))]));
-		const bunjaInstanceMap = new Map(bunja$1.relatedBunjas.map((relatedBunja) => [relatedBunja, this.#getBunjaInstance(relatedBunja, scopeInstanceMap)]));
+		const bunjaInstanceMap = new Map();
 		bunjaFn.use = (dep) => {
 			if (dep instanceof Bunja) return bunjaInstanceMap.get(dep).value;
 			if (dep instanceof Scope) return scopeInstanceMap.get(dep).value;
 			throw new Error("`bunja.use` can only be used with Bunja or Scope.");
 		};
+		for (const relatedBunja of bunja$1.relatedBunjas) bunjaInstanceMap.set(relatedBunja, this.#getBunjaInstance(relatedBunja, scopeInstanceMap));
 		const bunjaInstance = this.#getBunjaInstance(bunja$1, scopeInstanceMap);
 		return {
 			bunjaInstance,

package/dist/bunja.cjs

@@ -1,5 +1,5 @@
 "use strict";
-const require_bunja = require('./bunja-bUA1rGXy.cjs');
+const require_bunja = require('./bunja-RF4EuS_C.cjs');
 
 exports.Bunja = require_bunja.Bunja
 exports.BunjaStore = require_bunja.BunjaStore

package/dist/bunja.js

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

package/dist/react.cjs

@@ -22,11 +22,20 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const require_bunja = require('./bunja-bUA1rGXy.cjs');
-const { createContext, use, useEffect } = __toESM(require("react"));
+const require_bunja = require('./bunja-RF4EuS_C.cjs');
+const { createContext, createElement, use, useEffect, useState } = __toESM(require("react"));
 
 //#region react.ts
+"use client";
 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);
@@ -58,6 +67,7 @@ function inject(overrideTable) {
 
 //#endregion
 exports.BunjaStoreContext = BunjaStoreContext
+exports.BunjaStoreProvider = BunjaStoreProvider
 exports.bindScope = bindScope
 exports.createScopeFromContext = createScopeFromContext
 exports.inject = inject

package/dist/react.d.cts

@@ -1,6 +1,7 @@
-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 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>;

package/dist/react.d.ts

@@ -1,6 +1,7 @@
-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 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>;

package/dist/react.js

@@ -1,8 +1,17 @@
-import { createBunjaStore, createScope } from "./bunja-wcx846sL.js";
-import { createContext, use, useEffect } from "react";
+import { createBunjaStore, createScope } from "./bunja-DGNjfjPa.js";
+import { createContext, createElement, use, useEffect, useState } from "react";
 
 //#region react.ts
+"use client";
 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);
@@ -33,4 +42,4 @@ function inject(overrideTable) {
 }
 
 //#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": "2.0.0-alpha.1",
+  "version": "2.0.0-alpha.3",
   "description": "State Lifetime Manager",
   "main": "dist/bunja.cjs",
   "module": "dist/bunja.js",

package/react.ts

@@ -1,4 +1,14 @@
-import { type Context, createContext, use, useEffect } from "react";
+"use client";
+
+import {
+  type Context,
+  createContext,
+  createElement,
+  type PropsWithChildren,
+  use,
+  useEffect,
+  useState,
+} from "react";
 import {
   type Bunja,
   type BunjaStore,
@@ -13,6 +23,14 @@ export const BunjaStoreContext: Context<BunjaStore> = createContext(
   createBunjaStore(),
 );
 
+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>);