cajoa 0.1.0 → 0.3.0

package/README.md

@@ -1,14 +1,15 @@
 # Cajoa
 
-A small, beginner-friendly frontend framework built on **signals**.
+A small, beginner-friendly frontend framework built on **signals** and **JSX**.
 No virtual DOM, no hooks rules, no re-rendering components.
 
-> ⚠️ **v0.1 (early stage).** The API will change. Not production-ready yet.
+> ⚠️ **v0.3 (early stage).** The API may still change. Not production-ready yet.
 
 ## Why Cajoa?
 
 - **Components run once.** A component is just a function that builds DOM. Only the parts that depend on a signal update.
-- **Tiny and readable.** The whole core is a few hundred lines you can read in one sitting.
+- **Plain JSX.** Write `<button onClick={...}>`, no special syntax to learn.
+- **Tiny and readable.** The whole core is small enough to read in one sitting.
 - **TypeScript-first**, ESM + CommonJS, zero runtime dependencies.
 
 ## Install
@@ -17,60 +18,135 @@ No virtual DOM, no hooks rules, no re-rendering components.
 npm install cajoa
 ```
 
+## Setup (JSX)
+
+In your `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "jsxImportSource": "cajoa"
+  }
+}
+```
+
+If you use Vite and your JSX is not transformed, also set it in `vite.config.ts`
+(`oxc: { jsx: { runtime: "automatic", importSource: "cajoa" } }` on newer Vite,
+or `esbuild: { jsx: "automatic", jsxImportSource: "cajoa" }` on older ones).
+
 ## Quick start
 
-```ts
-import { createSignal, h, render } from "cajoa";
+```tsx
+import { createSignal, render } from "cajoa";
 
 function Counter() {
   const [count, setCount] = createSignal(0);
 
-  return h(
-    "button",
-    { onClick: () => setCount((c) => c + 1) },
-    "Clicked ",
-    count,
-    " times",
+  return (
+    <button onClick={() => setCount((c) => c + 1)}>
+      Clicked {count} times
+    </button>
   );
 }
 
 render(Counter, document.getElementById("app")!);
 ```
 
-Passing `count` (the function itself, not `count()`) is what makes that part of the DOM reactive.
+## Two rules to remember
+
+Cajoa has no compiler, so JSX expressions run exactly once. That gives two rules:
+
+1. **Pass the signal, don't call it.**
+   `{count}` is reactive. `{count()}` is read once and never updates.
+   For computed values, pass a function: `{() => count() * 2}`.
+2. **`Show` children are a function.**
+   `<Show when={on}>{() => <p>Hello</p>}</Show>`
+   Otherwise the element is created even when it is hidden.
+
+## Lists and conditions
+
+```tsx
+import { createSignal, Show, For } from "cajoa";
+
+const [todos, setTodos] = createSignal([{ id: 1, text: "Learn Cajoa" }]);
+
+<Show when={() => todos().length > 0} fallback={() => <p>Nothing to do.</p>}>
+  {() => (
+    <ul>
+      <For each={todos}>{(todo) => <li>{todo.text}</li>}</For>
+    </ul>
+  )}
+</Show>;
+```
 
 ## API
 
-| Function                             | What it does                                                             |
-| ------------------------------------ | ------------------------------------------------------------------------ |
-| `createSignal(value)`                | Returns `[get, set]`. Reading `get()` inside an effect subscribes to it. |
-| `createEffect(fn)`                   | Runs `fn` now and again whenever a signal it read changes.               |
-| `h(tag, props, ...children)`         | Creates a real DOM element. Function props/children are reactive.        |
-| `render(component, container)`       | Mounts a component. Returns a `dispose` function.                        |
-| `Show({ when, children, fallback })` | Conditional rendering.                                                   |
-| `For({ each, children })`            | List rendering.                                                          |
-| `onMount(fn)`                        | Runs `fn` after the component is rendered.                               |
-| `onCleanup(fn)`                      | Runs `fn` before an effect re-runs or when its owner is disposed.        |
-| `createRoot(fn)`                     | Creates a top-level owner you can dispose manually.                      |
+### Reactivity
+
+| Function              | What it does                                                                                                           |
+| --------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| `createSignal(value)` | Returns `[get, set]`. Reading `get()` inside an effect subscribes to it. `set` accepts a value or an updater function. |
+| `createEffect(fn)`    | Runs `fn` now and again whenever a signal it read changes.                                                             |
+| `createMemo(fn)`      | Cached computed value. Only notifies when the result changes.                                                          |
+| `batch(fn)`           | Groups several `set` calls into one update.                                                                            |
+
+### Components
+
+| Component              | What it does                                                                                         |
+| ---------------------- | ---------------------------------------------------------------------------------------------------- |
+| `<Show when fallback>` | Conditional rendering. `children` and `fallback` are functions.                                      |
+| `<For each key?>`      | List rendering. Reuses DOM nodes for unchanged items. The child is a function that returns a `Node`. |
+
+### Rendering
+
+| Function                       | What it does                                      |
+| ------------------------------ | ------------------------------------------------- |
+| `render(component, container)` | Mounts a component. Returns a `dispose` function. |
+| `h(tag, props, ...children)`   | Low-level element creator. JSX compiles to this.  |
+
+### Lifecycle
+
+| Function         | What it does                                                      |
+| ---------------- | ----------------------------------------------------------------- |
+| `onMount(fn)`    | Runs `fn` after the component is rendered.                        |
+| `onCleanup(fn)`  | Runs `fn` before an effect re-runs or when its owner is disposed. |
+| `createRoot(fn)` | Creates a top-level owner you can dispose manually.               |
+
+### Context
+
+| Function                  | What it does                                           |
+| ------------------------- | ------------------------------------------------------ |
+| `createContext(default)`  | Creates a context with a default value.                |
+| `provide(ctx, value, fn)` | Runs `fn`; everything created inside can read `value`. |
+| `useContext(ctx)`         | Reads the nearest provided value (or the default).     |
+
+## Good to know
+
+- `For` uses the item itself as the key by default. If you pass `key`, items with the same key are **not** re-rendered when their data changes, so keys must be unique and the item should hold its own signals if it needs to update.
+- `useContext` only works while a component is being created (or inside `onMount` / effects). Read it at the top of your component and use the value later in handlers.
+- Updating an object in place will not trigger effects. Set a new object instead.
 
 ## Known limitations
 
-- `For` rebuilds the whole list on every change (keyed diffing is planned).
-- No `createMemo`, `batch`, or context yet.
-- No JSX support yet (`h()` only).
+- No Fragments (`<>...</>`) yet. Wrap siblings in an element.
 - No SSR.
+- `createMemo` can show a brief inconsistent state when memos depend on each other.
+- `set` calls are not batched automatically inside event handlers. Wrap them in `batch()`.
 
 ## Roadmap
 
 - [x] Signals and effects
-- [x] DOM bindings (`h`, `render`)
-- [x] `Show`, `For`
-- [x] Lifecycle (`onMount`, `onCleanup`) and disposal
-- [ ] `createMemo`, `batch`
-- [ ] Keyed `For`
-- [ ] Context
-- [ ] JSX support
+- [x] DOM bindings and `render`
+- [x] `Show`, `For` (keyed)
+- [x] Lifecycle and disposal
+- [x] `createMemo`, `batch`
+- [x] Context
+- [x] JSX support
+- [ ] Fragments
+- [ ] Vite plugin (removes the two rules above)
 - [ ] Router
+- [ ] SSR
 
 ## Development
 

package/dist/index.cjs

@@ -22,13 +22,21 @@ var index_exports = {};
 __export(index_exports, {
   For: () => For,
   Show: () => Show,
+  batch: () => batch,
+  createContext: () => createContext,
   createEffect: () => createEffect,
+  createMemo: () => createMemo,
   createRoot: () => createRoot,
   createSignal: () => createSignal,
   h: () => h,
+  jsx: () => jsx,
+  jsxDEV: () => jsxDEV,
+  jsxs: () => jsxs,
   onCleanup: () => onCleanup,
   onMount: () => onMount,
-  render: () => render
+  provide: () => provide,
+  render: () => render,
+  useContext: () => useContext
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -45,6 +53,22 @@ function cleanComputation(c) {
   c.deps.clear();
   clean(c);
 }
+var batchDepth = 0;
+var pending = /* @__PURE__ */ new Set();
+function flush() {
+  const effects = [...pending];
+  pending.clear();
+  effects.forEach((effect) => effect.run());
+}
+function batch(fn) {
+  batchDepth++;
+  try {
+    return fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) flush();
+  }
+}
 function createSignal(value) {
   const subs = /* @__PURE__ */ new Set();
   const get = () => {
@@ -58,13 +82,18 @@ function createSignal(value) {
     const v = typeof next === "function" ? next(value) : next;
     if (Object.is(v, value)) return;
     value = v;
-    [...subs].forEach((effect) => effect.run());
+    for (const effect of [...subs]) {
+      if (batchDepth > 0)
+        pending.add(effect);
+      else effect.run();
+    }
   };
   return [get, set];
 }
 function createEffect(fn) {
   const effect = {
     cleanups: [],
+    parent: currentOwner,
     deps: /* @__PURE__ */ new Set(),
     disposed: false,
     run() {
@@ -92,7 +121,7 @@ function onCleanup(fn) {
   currentOwner?.cleanups.push(fn);
 }
 function createRoot(fn) {
-  const root = { cleanups: [] };
+  const root = { cleanups: [], parent: currentOwner };
   const prevOwner = currentOwner;
   const prevEffect = currentEffect;
   currentOwner = root;
@@ -119,6 +148,30 @@ function onMount(fn) {
     }
   });
 }
+function createContext(defaultValue) {
+  return { id: /* @__PURE__ */ Symbol("cajoa-context"), defaultValue };
+}
+function provide(ctx, value, fn) {
+  const owner = {
+    cleanups: [],
+    parent: currentOwner,
+    context: /* @__PURE__ */ new Map([[ctx.id, value]])
+  };
+  onCleanup(() => clean(owner));
+  const prev = currentOwner;
+  currentOwner = owner;
+  try {
+    return fn();
+  } finally {
+    currentOwner = prev;
+  }
+}
+function useContext(ctx) {
+  for (let o = currentOwner; o; o = o.parent) {
+    if (o.context?.has(ctx.id)) return o.context.get(ctx.id);
+  }
+  return ctx.defaultValue;
+}
 
 // src/dom/h.ts
 function h(tag, props, ...children) {
@@ -152,12 +205,12 @@ function toNodes(value) {
   return out;
 }
 function appendChildren(parent, children) {
-  const pending = [...children].reverse();
-  while (pending.length > 0) {
-    const child = pending.pop();
+  const pending2 = [...children].reverse();
+  while (pending2.length > 0) {
+    const child = pending2.pop();
     if (Array.isArray(child)) {
       for (let i = child.length - 1; i >= 0; i--) {
-        pending.push(child[i]);
+        pending2.push(child[i]);
       }
       continue;
     }
@@ -166,17 +219,29 @@ function appendChildren(parent, children) {
       const end = document.createComment("");
       parent.append(start, end);
       createEffect(() => {
-        const nodes = toNodes(child());
-        while (start.nextSibling && start.nextSibling !== end) {
-          start.nextSibling.remove();
-        }
-        end.before(...nodes);
+        reconcile(start, end, toNodes(child()));
       });
     } else {
       parent.append(...toNodes(child));
     }
   }
 }
+function reconcile(start, end, next) {
+  const keep = new Set(next);
+  let cur = start.nextSibling;
+  while (cur && cur !== end) {
+    const after = cur.nextSibling;
+    if (!keep.has(cur)) cur.remove();
+    cur = after;
+  }
+  const parent = end.parentNode;
+  let ref = start.nextSibling;
+  for (const node of next) {
+    if (node === ref)
+      ref = ref.nextSibling;
+    else parent.insertBefore(node, ref);
+  }
+}
 
 // src/dom/render.ts
 function render(component, container) {
@@ -196,17 +261,68 @@ function Show(props) {
 
 // src/components/for.ts
 function For(props) {
-  return () => props.each().map((item, i) => props.children(item, i));
+  let cache = /* @__PURE__ */ new Map();
+  onCleanup(() => {
+    cache.forEach((e) => e.dispose());
+    cache.clear();
+  });
+  return () => {
+    const items = props.each();
+    const next = /* @__PURE__ */ new Map();
+    const nodes = [];
+    items.forEach((item, i) => {
+      const k = props.key ? props.key(item, i) : item;
+      let entry = cache.get(k);
+      if (!entry) {
+        entry = createRoot((dispose) => ({
+          node: props.children(item, i),
+          dispose
+        }));
+      }
+      next.set(k, entry);
+      nodes.push(entry.node);
+    });
+    cache.forEach((entry, k) => {
+      if (!next.has(k)) entry.dispose();
+    });
+    cache = next;
+    return nodes;
+  };
+}
+
+// src/reactivity/memo.ts
+function createMemo(fn) {
+  const [value, setValue] = createSignal(void 0);
+  createEffect(() => setValue(() => fn()));
+  return value;
+}
+
+// src/jsx-runtime.ts
+function jsx(type, props) {
+  if (typeof type === "function") return type(props ?? {});
+  const { children, ...rest } = props ?? {};
+  const kids = children === void 0 ? [] : [children];
+  return h(type, rest, ...kids);
 }
+var jsxs = jsx;
+var jsxDEV = jsx;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   For,
   Show,
+  batch,
+  createContext,
   createEffect,
+  createMemo,
   createRoot,
   createSignal,
   h,
+  jsx,
+  jsxDEV,
+  jsxs,
   onCleanup,
   onMount,
-  render
+  provide,
+  render,
+  useContext
 });

package/dist/index.d.cts

@@ -1,9 +1,17 @@
 type Cleanup = () => void;
+declare function batch<T>(fn: () => T): T;
 declare function createSignal<T>(value: T): readonly [() => T, (next: T | ((prev: T) => T)) => void];
 declare function createEffect(fn: () => void): void;
 declare function onCleanup(fn: Cleanup): void;
 declare function createRoot<T>(fn: (dispose: () => void) => T): T;
 declare function onMount(fn: () => void): void;
+interface Context<T> {
+    readonly id: symbol;
+    readonly defaultValue: T;
+}
+declare function createContext<T>(defaultValue: T): Context<T>;
+declare function provide<T, R>(ctx: Context<T>, value: T, fn: () => R): R;
+declare function useContext<T>(ctx: Context<T>): T;
 
 type Child = string | number | boolean | null | undefined | Node | (() => unknown) | Child[];
 declare function h(tag: string, props: Record<string, any> | null, ...children: Child[]): HTMLElement;
@@ -18,8 +26,24 @@ declare function Show<T>(props: {
 
 declare function For<T>(props: {
     each: () => T[];
-    children: (item: T, index: number) => Child;
-}): () => Child[];
+    children: (item: T, index: number) => Node;
+    key?: (item: T, index: number) => unknown;
+}): () => Node[];
 
-export { For, Show, createEffect, createRoot, createSignal, h, onCleanup, onMount, render };
-export type { Child };
+declare function createMemo<T>(fn: () => T): () => T;
+
+declare function jsx(type: any, props: Record<string, any> | null): any;
+declare const jsxs: typeof jsx;
+declare const jsxDEV: typeof jsx;
+declare namespace JSX {
+    type Element = any;
+    interface IntrinsicElements {
+        [tag: string]: any;
+    }
+    interface ElementChildrenAttribute {
+        children: {};
+    }
+}
+
+export { For, JSX, Show, batch, createContext, createEffect, createMemo, createRoot, createSignal, h, jsx, jsxDEV, jsxs, onCleanup, onMount, provide, render, useContext };
+export type { Child, Context };

package/dist/index.d.ts

@@ -1,9 +1,17 @@
 type Cleanup = () => void;
+declare function batch<T>(fn: () => T): T;
 declare function createSignal<T>(value: T): readonly [() => T, (next: T | ((prev: T) => T)) => void];
 declare function createEffect(fn: () => void): void;
 declare function onCleanup(fn: Cleanup): void;
 declare function createRoot<T>(fn: (dispose: () => void) => T): T;
 declare function onMount(fn: () => void): void;
+interface Context<T> {
+    readonly id: symbol;
+    readonly defaultValue: T;
+}
+declare function createContext<T>(defaultValue: T): Context<T>;
+declare function provide<T, R>(ctx: Context<T>, value: T, fn: () => R): R;
+declare function useContext<T>(ctx: Context<T>): T;
 
 type Child = string | number | boolean | null | undefined | Node | (() => unknown) | Child[];
 declare function h(tag: string, props: Record<string, any> | null, ...children: Child[]): HTMLElement;
@@ -18,8 +26,24 @@ declare function Show<T>(props: {
 
 declare function For<T>(props: {
     each: () => T[];
-    children: (item: T, index: number) => Child;
-}): () => Child[];
+    children: (item: T, index: number) => Node;
+    key?: (item: T, index: number) => unknown;
+}): () => Node[];
 
-export { For, Show, createEffect, createRoot, createSignal, h, onCleanup, onMount, render };
-export type { Child };
+declare function createMemo<T>(fn: () => T): () => T;
+
+declare function jsx(type: any, props: Record<string, any> | null): any;
+declare const jsxs: typeof jsx;
+declare const jsxDEV: typeof jsx;
+declare namespace JSX {
+    type Element = any;
+    interface IntrinsicElements {
+        [tag: string]: any;
+    }
+    interface ElementChildrenAttribute {
+        children: {};
+    }
+}
+
+export { For, JSX, Show, batch, createContext, createEffect, createMemo, createRoot, createSignal, h, jsx, jsxDEV, jsxs, onCleanup, onMount, provide, render, useContext };
+export type { Child, Context };

package/dist/index.js

@@ -11,6 +11,22 @@ function cleanComputation(c) {
   c.deps.clear();
   clean(c);
 }
+var batchDepth = 0;
+var pending = /* @__PURE__ */ new Set();
+function flush() {
+  const effects = [...pending];
+  pending.clear();
+  effects.forEach((effect) => effect.run());
+}
+function batch(fn) {
+  batchDepth++;
+  try {
+    return fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) flush();
+  }
+}
 function createSignal(value) {
   const subs = /* @__PURE__ */ new Set();
   const get = () => {
@@ -24,13 +40,18 @@ function createSignal(value) {
     const v = typeof next === "function" ? next(value) : next;
     if (Object.is(v, value)) return;
     value = v;
-    [...subs].forEach((effect) => effect.run());
+    for (const effect of [...subs]) {
+      if (batchDepth > 0)
+        pending.add(effect);
+      else effect.run();
+    }
   };
   return [get, set];
 }
 function createEffect(fn) {
   const effect = {
     cleanups: [],
+    parent: currentOwner,
     deps: /* @__PURE__ */ new Set(),
     disposed: false,
     run() {
@@ -58,7 +79,7 @@ function onCleanup(fn) {
   currentOwner?.cleanups.push(fn);
 }
 function createRoot(fn) {
-  const root = { cleanups: [] };
+  const root = { cleanups: [], parent: currentOwner };
   const prevOwner = currentOwner;
   const prevEffect = currentEffect;
   currentOwner = root;
@@ -85,6 +106,30 @@ function onMount(fn) {
     }
   });
 }
+function createContext(defaultValue) {
+  return { id: /* @__PURE__ */ Symbol("cajoa-context"), defaultValue };
+}
+function provide(ctx, value, fn) {
+  const owner = {
+    cleanups: [],
+    parent: currentOwner,
+    context: /* @__PURE__ */ new Map([[ctx.id, value]])
+  };
+  onCleanup(() => clean(owner));
+  const prev = currentOwner;
+  currentOwner = owner;
+  try {
+    return fn();
+  } finally {
+    currentOwner = prev;
+  }
+}
+function useContext(ctx) {
+  for (let o = currentOwner; o; o = o.parent) {
+    if (o.context?.has(ctx.id)) return o.context.get(ctx.id);
+  }
+  return ctx.defaultValue;
+}
 
 // src/dom/h.ts
 function h(tag, props, ...children) {
@@ -118,12 +163,12 @@ function toNodes(value) {
   return out;
 }
 function appendChildren(parent, children) {
-  const pending = [...children].reverse();
-  while (pending.length > 0) {
-    const child = pending.pop();
+  const pending2 = [...children].reverse();
+  while (pending2.length > 0) {
+    const child = pending2.pop();
     if (Array.isArray(child)) {
       for (let i = child.length - 1; i >= 0; i--) {
-        pending.push(child[i]);
+        pending2.push(child[i]);
       }
       continue;
     }
@@ -132,17 +177,29 @@ function appendChildren(parent, children) {
       const end = document.createComment("");
       parent.append(start, end);
       createEffect(() => {
-        const nodes = toNodes(child());
-        while (start.nextSibling && start.nextSibling !== end) {
-          start.nextSibling.remove();
-        }
-        end.before(...nodes);
+        reconcile(start, end, toNodes(child()));
       });
     } else {
       parent.append(...toNodes(child));
     }
   }
 }
+function reconcile(start, end, next) {
+  const keep = new Set(next);
+  let cur = start.nextSibling;
+  while (cur && cur !== end) {
+    const after = cur.nextSibling;
+    if (!keep.has(cur)) cur.remove();
+    cur = after;
+  }
+  const parent = end.parentNode;
+  let ref = start.nextSibling;
+  for (const node of next) {
+    if (node === ref)
+      ref = ref.nextSibling;
+    else parent.insertBefore(node, ref);
+  }
+}
 
 // src/dom/render.ts
 function render(component, container) {
@@ -162,16 +219,67 @@ function Show(props) {
 
 // src/components/for.ts
 function For(props) {
-  return () => props.each().map((item, i) => props.children(item, i));
+  let cache = /* @__PURE__ */ new Map();
+  onCleanup(() => {
+    cache.forEach((e) => e.dispose());
+    cache.clear();
+  });
+  return () => {
+    const items = props.each();
+    const next = /* @__PURE__ */ new Map();
+    const nodes = [];
+    items.forEach((item, i) => {
+      const k = props.key ? props.key(item, i) : item;
+      let entry = cache.get(k);
+      if (!entry) {
+        entry = createRoot((dispose) => ({
+          node: props.children(item, i),
+          dispose
+        }));
+      }
+      next.set(k, entry);
+      nodes.push(entry.node);
+    });
+    cache.forEach((entry, k) => {
+      if (!next.has(k)) entry.dispose();
+    });
+    cache = next;
+    return nodes;
+  };
+}
+
+// src/reactivity/memo.ts
+function createMemo(fn) {
+  const [value, setValue] = createSignal(void 0);
+  createEffect(() => setValue(() => fn()));
+  return value;
+}
+
+// src/jsx-runtime.ts
+function jsx(type, props) {
+  if (typeof type === "function") return type(props ?? {});
+  const { children, ...rest } = props ?? {};
+  const kids = children === void 0 ? [] : [children];
+  return h(type, rest, ...kids);
 }
+var jsxs = jsx;
+var jsxDEV = jsx;
 export {
   For,
   Show,
+  batch,
+  createContext,
   createEffect,
+  createMemo,
   createRoot,
   createSignal,
   h,
+  jsx,
+  jsxDEV,
+  jsxs,
   onCleanup,
   onMount,
-  render
+  provide,
+  render,
+  useContext
 };

package/package.json

@@ -1,57 +1,78 @@
-{
-  "name": "cajoa",
-  "version": "0.1.0",
-  "description": "A beginner-friendly, signals-based frontend framework.",
-  "type": "module",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "sideEffects": false,
-  "scripts": {
-    "typecheck": "tsc --noEmit",
-    "dev": "vite --open /playground/",
-    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
-    "test": "vitest",
-    "prepublishOnly": "vitest run && npm run build"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/cjmgrc/Cajoa.git"
-  },
-  "keywords": [
-    "frontend",
-    "framework",
-    "signals",
-    "reactive",
-    "ui",
-    "cajoa"
-  ],
-  "author": "cjmgrc",
-  "license": "Apache-2.0",
-  "bugs": {
-    "url": "https://github.com/cjmgrc/Cajoa/issues"
-  },
-  "homepage": "https://github.com/cjmgrc/Cajoa#readme",
-  "devDependencies": {
-    "jsdom": "^29.1.1",
-    "tsup": "^9.0.0",
-    "typescript": "^5.9.3",
-    "vite": "^8.3.4",
-    "vitest": "^5.0.5"
-  }
-}
+{
+  "name": "cajoa",
+  "version": "0.3.0",
+  "description": "A beginner-friendly, signals-based frontend framework.",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./jsx-runtime": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./jsx-dev-runtime": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "dev": "vite --open /playground/",
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "test": "vitest",
+    "prepublishOnly": "vitest run && npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CajoaTS/Cajoa.git"
+  },
+  "keywords": [
+    "frontend",
+    "framework",
+    "signals",
+    "reactive",
+    "ui",
+    "cajoa"
+  ],
+  "author": "cjmgrc",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/CajoaTS/Cajoa/issues"
+  },
+  "homepage": "https://github.com/CajoaTS/Cajoa#readme",
+  "devDependencies": {
+    "@types/node": "^26.6.5",
+    "jsdom": "^29.1.1",
+    "tsup": "^9.0.0",
+    "typescript": "^5.9.3",
+    "vite": "^8.3.4",
+    "vitest": "^5.0.5"
+  }
+}