bunja 0.0.12 → 1.0.0

package/react.ts

@@ -1,21 +1,28 @@
-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 HashFn,
+  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);
 }
 
-export function createScopeFromContext<T>(context: Context<T>): Scope<T> {
-  const scope = createScope();
+export function createScopeFromContext<T>(
+  context: Context<T>,
+  hash?: HashFn<T>,
+): Scope<T> {
+  const scope = createScope(hash);
   bindScope(scope, context);
   return scope;
 }
@@ -25,7 +32,10 @@ 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, deps } = store.get(bunja, readScope);
   useEffect(mount, deps);
@@ -35,7 +45,7 @@ export function useBunja<T>(bunja: Bunja<T>, readScope = defaultReadScope): T {
 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 +53,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/test.ts

@@ -0,0 +1,206 @@
+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";
+
+const readNull = () => (null as any);
+
+Deno.test({
+  name: "basic",
+  fn() {
+    using time = new FakeTime();
+    const store = createBunjaStore();
+    const myBunjaInstance = {};
+    const myBunja = bunja([], () => myBunjaInstance);
+    const { value, mount } = store.get(myBunja, readNull);
+    const cleanup = mount();
+    cleanup();
+    assertEquals(value, myBunjaInstance);
+    time.tick();
+  },
+});
+
+Deno.test({
+  name: "basic effect",
+  fn() {
+    using time = new FakeTime();
+    const store = createBunjaStore();
+    const mountSpy = spy();
+    const unmountSpy = spy();
+    const myBunja = bunja([], () => ({
+      [bunja.effect]() {
+        mountSpy();
+        return unmountSpy;
+      },
+    }));
+    assertSpyCalls(mountSpy, 0);
+    const { mount } = store.get(myBunja, readNull);
+    assertSpyCalls(mountSpy, 0);
+    const cleanup = mount();
+    assertSpyCalls(mountSpy, 1);
+    assertSpyCalls(unmountSpy, 0);
+    cleanup();
+    assertSpyCalls(unmountSpy, 0);
+    time.tick();
+    assertSpyCalls(unmountSpy, 1);
+  },
+});
+
+Deno.test({
+  name: "bunja that depend on other bunja",
+  fn() {
+    using time = new FakeTime();
+    const store = createBunjaStore();
+    const [aMountSpy, aUnmountSpy] = [spy(), spy()];
+    const [bMountSpy, bUnmountSpy] = [spy(), spy()];
+    const aBunjaInstance = {
+      [bunja.effect]() {
+        aMountSpy();
+        return aUnmountSpy;
+      },
+    };
+    const aBunja = bunja([], () => aBunjaInstance);
+    const bBunja = bunja([aBunja], (a) => ({
+      a,
+      [bunja.effect]() {
+        bMountSpy();
+        return bUnmountSpy;
+      },
+    }));
+    assertSpyCalls(aMountSpy, 0);
+    assertSpyCalls(bMountSpy, 0);
+    const { value, mount } = store.get(bBunja, readNull);
+    assertEquals(value.a, aBunjaInstance);
+    assertSpyCalls(aMountSpy, 0);
+    assertSpyCalls(bMountSpy, 0);
+    const cleanup = mount();
+    assertSpyCalls(aMountSpy, 1);
+    assertSpyCalls(bMountSpy, 1);
+    assertSpyCalls(aUnmountSpy, 0);
+    assertSpyCalls(bUnmountSpy, 0);
+    cleanup();
+    assertSpyCalls(aUnmountSpy, 0);
+    assertSpyCalls(bUnmountSpy, 0);
+    time.tick();
+    assertSpyCalls(aUnmountSpy, 1);
+    assertSpyCalls(bUnmountSpy, 1);
+  },
+});
+
+Deno.test({
+  name: "A mount first, B mount later & A unmount first, B unmount later",
+  fn() {
+    using time = new FakeTime();
+    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 { mount: m1 } = store.get(aBunja, readNull);
+    const c1 = m1();
+    assertSpyCalls(aMountSpy, 1);
+    assertSpyCalls(bMountSpy, 0);
+    const { mount: m2 } = store.get(bBunja, readNull);
+    const c2 = m2();
+    assertSpyCalls(aMountSpy, 1);
+    assertSpyCalls(bMountSpy, 1);
+    assertSpyCalls(aUnmountSpy, 0);
+    assertSpyCalls(bUnmountSpy, 0);
+    c1();
+    time.tick();
+    assertSpyCalls(aUnmountSpy, 0);
+    assertSpyCalls(bUnmountSpy, 0);
+    c2();
+    time.tick();
+    assertSpyCalls(aUnmountSpy, 1);
+    assertSpyCalls(bUnmountSpy, 1);
+  },
+});
+
+Deno.test({
+  name: "B mount first, A mount later & B unmount first, A unmount later",
+  fn() {
+    using time = new FakeTime();
+    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 { mount: m1 } = store.get(bBunja, readNull);
+    const c1 = m1();
+    assertSpyCalls(aMountSpy, 1);
+    assertSpyCalls(bMountSpy, 1);
+    const { mount: m2 } = store.get(aBunja, readNull);
+    const c2 = m2();
+    assertSpyCalls(aMountSpy, 1);
+    assertSpyCalls(bMountSpy, 1);
+    assertSpyCalls(aUnmountSpy, 0);
+    assertSpyCalls(bUnmountSpy, 0);
+    c1();
+    time.tick();
+    assertSpyCalls(aUnmountSpy, 0);
+    assertSpyCalls(bUnmountSpy, 1);
+    c2();
+    time.tick();
+    assertSpyCalls(aUnmountSpy, 1);
+    assertSpyCalls(bUnmountSpy, 1);
+  },
+});
+
+Deno.test({
+  name: "injecting values into a scope when calling store.get",
+  fn() {
+    using time = new FakeTime();
+    const store = createBunjaStore();
+    const myScope = createScope<string>();
+    const myBunja = bunja([myScope], (scopeValue) => ({ scopeValue }));
+    const readScope = <T>(): T => "injected value" as T;
+    const { value: { scopeValue }, mount } = store.get(myBunja, readScope);
+    const cleanup = mount();
+    cleanup();
+    assertEquals(scopeValue, "injected value");
+    time.tick();
+  },
+});
+
+Deno.test({
+  name: "scope value deduplication using hash function",
+  fn() {
+    using time = new FakeTime();
+    const store = createBunjaStore();
+    const myScope = createScope<string>(({ length }) => length);
+    const myBunja = bunja([myScope], (scopeValue) => ({ scopeValue }));
+    const { value: { scopeValue: scopeValue1 }, mount: mount1 } = store.get(
+      myBunja,
+      <T>() => "foo" as T,
+    );
+    const cleanup1 = mount1();
+    const { value: { scopeValue: scopeValue2 }, mount: mount2 } = store.get(
+      myBunja,
+      <T>() => "bar" as T,
+    );
+    const cleanup2 = mount2();
+    const { value: { scopeValue: scopeValue3 }, mount: mount3 } = store.get(
+      myBunja,
+      <T>() => "baaz" as T,
+    );
+    const cleanup3 = mount3();
+    assertEquals(scopeValue1, "foo");
+    assertEquals(scopeValue2, "foo");
+    assertEquals(scopeValue3, "baaz");
+    cleanup1();
+    cleanup2();
+    cleanup3();
+    time.tick();
+  },
+});

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;