bunja 2.0.0-alpha.1 → 2.0.0-alpha.2

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.2",
   "license": "Zlib",
   "exports": {
     ".": "./bunja.ts",

package/dist/react.cjs

@@ -23,10 +23,18 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 const require_bunja = require('./bunja-bUA1rGXy.cjs');
-const { createContext, use, useEffect } = __toESM(require("react"));
+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);
@@ -58,6 +66,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,16 @@
 import { createBunjaStore, createScope } from "./bunja-wcx846sL.js";
-import { createContext, use, useEffect } from "react";
+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);
@@ -33,4 +41,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.2",
   "description": "State Lifetime Manager",
   "main": "dist/bunja.cjs",
   "module": "dist/bunja.js",

package/react.ts

@@ -1,4 +1,12 @@
-import { type Context, createContext, use, useEffect } from "react";
+import {
+  type Context,
+  createContext,
+  createElement,
+  type PropsWithChildren,
+  use,
+  useEffect,
+  useState,
+} from "react";
 import {
   type Bunja,
   type BunjaStore,
@@ -13,6 +21,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>);