@italone/solace 0.0.1

package/dist/jsx-dev-runtime.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var jsxRuntime = require('./jsx-runtime.cjs');
+var h = require('./h-CSqpvOof.cjs');
+
+function jsxDEV(type, props, key) {
+    return jsxRuntime.jsx(type, props, key);
+}
+
+exports.jsx = jsxRuntime.jsx;
+exports.jsxs = jsxRuntime.jsxs;
+exports.Fragment = h.Fragment;
+exports.jsxDEV = jsxDEV;

package/dist/jsx-dev-runtime.d.ts

@@ -0,0 +1,7 @@
+import { jsx, JSX } from './jsx-runtime.js';
+export { jsxs } from './jsx-runtime.js';
+export { F as Fragment } from './vnode-zJOgBYFm.js';
+
+declare function jsxDEV(type: Parameters<typeof jsx>[0], props: Parameters<typeof jsx>[1], key?: string): JSX.Element;
+
+export { JSX, jsx, jsxDEV };

package/dist/jsx-dev-runtime.js

@@ -0,0 +1,9 @@
+import { jsx } from './jsx-runtime.js';
+export { jsxs } from './jsx-runtime.js';
+export { F as Fragment } from './h-B1loyNPC.js';
+
+function jsxDEV(type, props, key) {
+    return jsx(type, props, key);
+}
+
+export { jsx, jsxDEV };

package/dist/jsx-runtime.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+var h = require('./h-CSqpvOof.cjs');
+
+function jsx(type, props = null, key) {
+    return createJsxVNode(type, props, key);
+}
+function jsxs(type, props = null, key) {
+    return createJsxVNode(type, props, key);
+}
+function createJsxVNode(type, props, key) {
+    const { children, ...restProps } = props ?? {};
+    const vnodeProps = {
+        ...restProps,
+        ...(key !== undefined ? { key } : {}),
+    };
+    return h.h(type, vnodeProps, normalizeChildren(children));
+}
+function normalizeChildren(children) {
+    if (Array.isArray(children)) {
+        const normalized = children
+            .filter((child) => child !== null && child !== undefined && typeof child !== "boolean")
+            .map((child) => (typeof child === "number" ? String(child) : child));
+        if (normalized.every((child) => typeof child === "string")) {
+            return normalized.join("");
+        }
+        return normalized.map((child) => typeof child === "string" ? h.h("span", null, child) : child);
+    }
+    if (children === null || children === undefined || typeof children === "boolean") {
+        return null;
+    }
+    if (typeof children === "number") {
+        return String(children);
+    }
+    return typeof children === "string" ? children : [children];
+}
+
+exports.Fragment = h.Fragment;
+exports.jsx = jsx;
+exports.jsxs = jsxs;

package/dist/jsx-runtime.d.ts

@@ -0,0 +1,24 @@
+import { V as VNode, a as VNodeProps, k as VNodeChild, d as VNodeType } from './vnode-zJOgBYFm.js';
+export { F as Fragment } from './vnode-zJOgBYFm.js';
+
+type JSXChild = VNodeChild | number | boolean | null | undefined;
+type JSXChildren = JSXChild | JSXChild[];
+type JSXProps = VNodeProps & {
+    children?: JSXChildren;
+};
+
+declare function jsx(type: VNodeType, props?: JSXProps | null, key?: string): VNode;
+declare function jsxs(type: VNodeType, props?: JSXProps | null, key?: string): VNode;
+declare namespace JSX {
+    type Element = VNode;
+    interface IntrinsicElements {
+        [name: string]: VNodeProps & {
+            children?: JSXChildren;
+        };
+    }
+    interface ElementChildrenAttribute {
+        children: unknown;
+    }
+}
+
+export { JSX, jsx, jsxs };

package/dist/jsx-runtime.js

@@ -0,0 +1,37 @@
+import { h } from './h-B1loyNPC.js';
+export { F as Fragment } from './h-B1loyNPC.js';
+
+function jsx(type, props = null, key) {
+    return createJsxVNode(type, props, key);
+}
+function jsxs(type, props = null, key) {
+    return createJsxVNode(type, props, key);
+}
+function createJsxVNode(type, props, key) {
+    const { children, ...restProps } = props ?? {};
+    const vnodeProps = {
+        ...restProps,
+        ...(key !== undefined ? { key } : {}),
+    };
+    return h(type, vnodeProps, normalizeChildren(children));
+}
+function normalizeChildren(children) {
+    if (Array.isArray(children)) {
+        const normalized = children
+            .filter((child) => child !== null && child !== undefined && typeof child !== "boolean")
+            .map((child) => (typeof child === "number" ? String(child) : child));
+        if (normalized.every((child) => typeof child === "string")) {
+            return normalized.join("");
+        }
+        return normalized.map((child) => typeof child === "string" ? h("span", null, child) : child);
+    }
+    if (children === null || children === undefined || typeof children === "boolean") {
+        return null;
+    }
+    if (typeof children === "number") {
+        return String(children);
+    }
+    return typeof children === "string" ? children : [children];
+}
+
+export { jsx, jsxs };

package/dist/vnode-zJOgBYFm.d.ts

@@ -0,0 +1,43 @@
+declare enum ShapeFlags {
+    ELEMENT = 1,
+    TEXT_CHILDREN = 2,
+    ARRAY_CHILDREN = 4,
+    COMPONENT = 8,
+    FRAGMENT = 16
+}
+
+type EmitFn = (event: string, ...args: unknown[]) => void;
+type SlotProps = Record<string, unknown>;
+type Slot = (props?: SlotProps) => VNodeChildren;
+interface Slots {
+    default?: Slot;
+    [name: string]: Slot | undefined;
+}
+interface ComponentSetupContext {
+    emit: EmitFn;
+    slots: Slots;
+}
+
+type ComponentProps = Record<string, unknown>;
+type ComponentRender = () => VNode;
+type ComponentType<Props extends object = ComponentProps> = (props: Props, context: ComponentSetupContext) => ComponentRender | VNode;
+declare const Fragment: unique symbol;
+type FragmentType = typeof Fragment;
+type VNodeType = string | ComponentType<never> | FragmentType;
+type VNodeProps = Record<string, unknown>;
+type VNodeChild = string | VNode;
+type VNodeChildren = string | VNode | VNode[] | null;
+type VNodeSlots = Record<string, Slot>;
+type ComponentVNodeChildren = VNodeChildren | VNodeSlots;
+interface VNode {
+    type: VNodeType;
+    props: VNodeProps | null;
+    key: string | number | null;
+    children: ComponentVNodeChildren;
+    shapeFlag: ShapeFlags;
+    el: Element | Text | null;
+    component: unknown;
+}
+
+export { Fragment as F };
+export type { ComponentType as C, EmitFn as E, Slot as S, VNode as V, VNodeProps as a, VNodeChildren as b, ComponentVNodeChildren as c, VNodeType as d, ComponentRender as e, ComponentSetupContext as f, ComponentProps as g, FragmentType as h, SlotProps as i, Slots as j, VNodeChild as k, VNodeSlots as l };

package/docs/api.md

@@ -0,0 +1,302 @@
+# API
+
+## Public Root Export
+
+The `solace` package root exposes the stable runtime surface:
+
+- App: `createApp`
+- Reactivity: `reactive`, `effect`, `computed`, `ref`, `watch`, `watchEffect`
+- Rendering: `h`, `render`, `Fragment`
+- Components: `defineComponent`, `defineAsyncComponent`, default slots
+- Component context: `provide`, `inject`
+- Lifecycle: `onMounted`, `onUpdated`, `onUnmounted`
+- Scheduler: `nextTick`
+- Store: `createStore`
+
+Public TypeScript types include `App`, `AsyncComponentLoader`, `AsyncComponentOptions`, `AsyncComponentSource`, `ComponentSetupContext`, `EmitFn`, `Slot`, `Slots`, `Store`, `StoreContext`, `StoreGetterContext`, `StoreGetters`, `StoreOptions`, `VNode`, `VNodeProps`, and related component/VNode helper types.
+
+Internal helpers such as scheduler queues, shape flags, component instance setup, and VNode factory internals are not exported from the package root.
+
+## App
+
+### `createApp(rootComponent)`
+
+Creates an app wrapper around a root component or VNode.
+
+```ts
+import { createApp, h } from "solace";
+
+const App = () => h("p", null, "hello");
+
+createApp(App).mount(document.querySelector("#app") as Element);
+```
+
+Returns:
+
+- `mount(container: Element): void`
+- `provide(key, value): App`
+- `use(plugin, ...options): App`
+
+Provide an app-level value before mounting. Components can read it with `inject()`, and component-level
+providers override app-level values.
+
+```ts
+import { createApp } from "solace";
+
+createApp(App)
+  .provide("theme", "dark")
+  .mount(document.querySelector("#app") as Element);
+```
+
+Install a plugin before mounting an app. A plugin can be a function or an object with `install`.
+Each plugin is installed once per app instance, and `use()` returns the app for chaining. Plugins can
+also call `app.provide()` to expose values to the mounted component tree.
+
+```ts
+import { createApp } from "solace";
+import type { App, Plugin } from "solace";
+
+const plugin: Plugin = (app: App, option) => {
+  app.provide("theme", "dark");
+  console.log(app, option);
+};
+
+createApp(App)
+  .use(plugin, "enabled")
+  .mount(document.querySelector("#app") as Element);
+```
+
+## Reactivity
+
+### `reactive(target)`
+
+Wraps an object in a reactive proxy.
+
+```ts
+const state = reactive({ count: 0 });
+state.count += 1;
+```
+
+### `effect(fn)`
+
+Runs `fn` immediately and reruns it when tracked dependencies change.
+
+```ts
+effect(() => {
+  console.log(state.count);
+});
+```
+
+### `computed(getter)`
+
+Returns a cached ref-like object with readonly `.value`.
+
+```ts
+const double = computed(() => state.count * 2);
+console.log(double.value);
+```
+
+### `ref(value)`
+
+Creates a reactive value holder.
+
+```ts
+const count = ref(0);
+count.value += 1;
+```
+
+### `watch(source, callback)`
+
+Runs `callback` when the source result changes.
+
+```ts
+watch(
+  () => state.count,
+  (value, oldValue) => {
+    console.log(value, oldValue);
+  },
+);
+```
+
+### `watchEffect(effect)`
+
+Runs `effect` immediately and reruns it when tracked dependencies change.
+
+```ts
+const stop = watchEffect(() => {
+  console.log(state.count);
+});
+
+stop();
+```
+
+## Rendering
+
+### `h(type, props?, children?)`
+
+Creates a VNode for an element, component, or Fragment.
+
+```ts
+h("button", { onClick: save }, "Save");
+```
+
+### `render(vnode, container)`
+
+Mounts or patches a VNode into a DOM container.
+
+```ts
+render(h(App), document.querySelector("#app") as Element);
+```
+
+### `Fragment`
+
+Groups multiple children without an extra DOM wrapper.
+
+## Components
+
+Function components receive props and a setup context with `emit` and `slots`.
+
+```ts
+import { h } from "solace";
+import type { ComponentSetupContext } from "solace";
+
+const Button = (props: { label: string }, { emit }: ComponentSetupContext) =>
+  h("button", { onClick: () => emit("change") }, props.label);
+
+const Panel =
+  (_props: object, { slots }: ComponentSetupContext) =>
+  () =>
+    h("section", null, [
+      h("header", null, slots.header?.() ?? null),
+      h("main", null, slots.default?.({ text: "Body" }) ?? null),
+    ]);
+
+h(Panel, null, {
+  header: () => h("h1", null, "Title"),
+  default: (slotProps) => h("p", null, String(slotProps?.text)),
+});
+```
+
+### `defineComponent(component)`
+
+Declares a Solace component while preserving the existing function component contract.
+
+```ts
+import { defineComponent, h } from "solace";
+
+const Button = defineComponent((props: { label: string }) => h("button", null, props.label));
+```
+
+### `defineAsyncComponent(loader | options)`
+
+Declares a component that loads another component asynchronously. While the loader is pending,
+the wrapper renders an empty Fragment or `loadingComponent`. If the loader rejects, it renders
+`errorComponent` when provided. Resolved, loading, and error components receive the latest props
+and default slot children. Use `delay` to postpone the loading component and `timeout` to enter
+the error state when loading takes too long. Use `retry` to make additional attempts after loader
+rejection or timeout, and `retryDelay` to wait before each retry.
+
+```ts
+import { defineAsyncComponent, h } from "solace";
+
+const LazyMessage = defineAsyncComponent<{ text: string }>(() =>
+  Promise.resolve((props: { text: string }) => h("p", null, props.text)),
+);
+
+const LazyPanel = defineAsyncComponent<{ title: string }>({
+  loader: () => Promise.resolve((props: { title: string }) => h("section", null, props.title)),
+  loadingComponent: () => h("span", null, "loading"),
+  errorComponent: () => h("strong", null, "failed"),
+  delay: 200,
+  timeout: 3000,
+  retry: 2,
+  retryDelay: 100,
+});
+```
+
+### `provide(key, value)` / `inject(key, defaultValue?)`
+
+Passes values from an ancestor component setup to descendant component setup without prop drilling.
+
+```ts
+import { h, inject, provide } from "solace";
+
+const ThemeKey = Symbol("theme");
+
+const Child = () => {
+  const theme = inject(ThemeKey, "light");
+
+  return () => h("span", null, theme);
+};
+
+const Parent = () => {
+  provide(ThemeKey, "dark");
+
+  return () => h(Child);
+};
+```
+
+### Lifecycle
+
+- `onMounted(hook)`
+- `onUpdated(hook)`
+- `onUnmounted(hook)`
+
+Lifecycle hooks register during component setup.
+
+## Scheduler
+
+### `nextTick()`
+
+Resolves after queued component updates flush.
+
+```ts
+state.count += 1;
+await nextTick();
+```
+
+## Store
+
+### `createStore({ state, getters, actions })`
+
+Creates a small centralized store.
+
+```ts
+import { createStore } from "solace";
+import type { StoreContext, StoreGetterContext } from "solace";
+
+const store = createStore({
+  state: () => ({ count: 0 }),
+  getters: {
+    double({ state }: StoreGetterContext<{ count: number }>) {
+      return state.count * 2;
+    },
+  },
+  actions: {
+    increment({ state }: StoreContext<{ count: number }, { double: number }>, amount: number) {
+      state.count += amount;
+    },
+  },
+});
+
+store.actions.increment(1);
+console.log(store.getters.double);
+```
+
+## JSX
+
+Use TypeScript automatic JSX runtime:
+
+```json
+{
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "jsxImportSource": "solace"
+  }
+}
+```
+
+Public JSX entry points:
+
+- `solace/jsx-runtime`
+- `solace/jsx-dev-runtime`

package/docs/architecture.md

@@ -0,0 +1,80 @@
+# Architecture
+
+## Layers
+
+Solace is organized as a small runtime pipeline:
+
+```text
+reactivity -> scheduler -> component -> vnode -> renderer -> DOM
+```
+
+- `reactivity`: tracks reads and triggers effects on writes.
+- `scheduler`: batches component update jobs and exposes `nextTick`.
+- `component`: creates component instances, owns props, render effects, emit, and lifecycle hooks.
+- `vnode`: represents elements, components, Fragment, props, keys, and children.
+- `renderer`: mounts, patches, diffs, and unmounts VNodes.
+- `event`: patches DOM event listeners through invoker caching.
+- `store`: composes `reactive` and `computed` into a centralized state container.
+
+## Update Flow
+
+1. A component render function reads reactive state.
+2. The active component `ReactiveEffect` tracks those reads.
+3. A state write calls `trigger`.
+4. The component effect scheduler queues the component update with `queueJob`.
+5. The queued job reruns the component render.
+6. The renderer patches the previous subtree against the next subtree.
+7. `nextTick` resolves after the scheduler queue is flushed.
+
+## Component Flow
+
+Mounting a component creates a `ComponentInstance` with:
+
+- `vnode`, `type`, `props`, `subTree`
+- `render`, `effect`, `update`
+- `emit`
+- lifecycle arrays for mounted, updated, and unmounted hooks
+
+The first render mounts the component subtree. Later renders patch the old subtree against the new subtree. Unmounting stops the component effect, recursively unmounts the subtree, and calls unmounted hooks.
+
+## DOM Patch Flow
+
+The renderer compares VNode type and key:
+
+- Different type or key: unmount old node, mount new node.
+- Same element: patch props, then patch children.
+- Same component: update props, then run the component update.
+- Fragment: patch or unmount its children without adding a wrapper element.
+
+Children diff favors correctness and DOM reuse. Keyed children support insert, delete, move, and patch, and the
+keyed-middle path uses LIS optimization to avoid unnecessary DOM moves.
+
+## Event Flow
+
+DOM event props use the `onXxx` convention. Each DOM element caches event invokers:
+
+- First listener: add one native listener.
+- Handler update: replace `invoker.value`.
+- Prop removal or element unmount: remove the cached native listener.
+
+This avoids repeated add/remove work when only the handler function changes.
+
+## Package Shape
+
+The package exposes:
+
+- `solace`: root runtime APIs.
+- `solace/jsx-runtime`: automatic JSX runtime.
+- `solace/jsx-dev-runtime`: development JSX runtime.
+
+Rollup builds ESM, CJS, and `.d.ts` artifacts for each public entry point.
+
+## Examples
+
+The Vite examples in `examples/` exercise the package through local aliases:
+
+- `basic-counter`: JSX runtime, reactive state, and DOM events.
+- `todo-app`: form input, keyed list updates, checkbox state, and deletion.
+- `large-list`: 10,000 keyed rows and targeted text/class patching.
+
+See `docs/examples.md` for run commands and e2e coverage.