@pumped-fn/lite-react-json-render 0.0.0

package/CHANGELOG.md

@@ -0,0 +1 @@
+# @pumped-fn/lite-react-json-render

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License Copyright (c) 2025 Duke
+
+Permission is hereby granted, free of
+charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice
+(including the next paragraph) shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,157 @@
+# @pumped-fn/lite-react-json-render
+
+json-render state and action adapters for `@pumped-fn/lite-react`.
+
+Use this package when a json-render spec should bind to Lite-owned frontend state and emit actions into
+Lite-owned flows. `@pumped-fn/lite-react` still owns the scope, execution context, scoped value, resources,
+tags, presets, and tests; json-render reads, writes, and emits through its normal provider contracts.
+
+## When to Use
+
+Use these adapters when json-render is already the right UI boundary: generated specs, server-authored
+forms, schema-driven editors, or embedded surfaces that need json-render's `$state`, `$bindState`, `on`,
+or `watch` contracts. The timing is the integration edge, after the draft/form/editor state and action
+flows have clear Lite owners.
+
+Do not use it to make ordinary React components more indirect. If the UI is hand-authored React, render forms
+and drafts from `useScopedValue` and mutate through scoped actions. Use `useResource` when an integration
+boundary needs the resolved access object. If json-render should own isolated state that never needs Lite
+flows, resources, resets, or tests, use json-render's own store and handlers instead.
+
+## Install
+
+```bash
+npm install @pumped-fn/lite @pumped-fn/lite-react @pumped-fn/lite-react-json-render
+npm install @json-render/core @json-render/react zod
+```
+
+## Usage
+
+```tsx
+import { JSONUIProvider, type ComponentRegistry } from "@json-render/react"
+import { flow, tag } from "@pumped-fn/lite"
+import { scopedValue, type ScopedValueAccess, useResource } from "@pumped-fn/lite-react"
+import { flowAction, scopedValueStateStore, useFlowHandlers } from "@pumped-fn/lite-react-json-render"
+import { useMemo } from "react"
+import { z } from "zod"
+
+interface OrderState {
+  order: {
+    item: string
+    quantity: number
+  }
+  submission: {
+    message: string
+  } | null
+}
+
+const submitOrderInput = z.object({
+  item: z.string(),
+  quantity: z.number(),
+})
+
+const currentOrderDraft = tag<ScopedValueAccess<OrderState>>({
+  label: "current.order-draft",
+})
+
+const orderDraft = scopedValue({
+  name: "order-draft",
+  initial: (): OrderState => ({
+    order: { item: "Coffee", quantity: 1 },
+    submission: null,
+  }),
+})
+
+const submitOrder = flow({
+  name: "submit-order",
+  parse: submitOrderInput.parse,
+  factory: (ctx) => {
+    const draft = ctx.data.getTag(currentOrderDraft)!
+    const message = `Submitted ${ctx.input.item} x ${ctx.input.quantity}`
+    draft.patch({ submission: { message } })
+    return message
+  },
+})
+
+function GeneratedOrder(
+  { registry, children }: { registry: ComponentRegistry; children: React.ReactNode }
+) {
+  const draft = useResource(orderDraft)
+
+  return (
+    <OrderBridge registry={registry} draft={draft}>
+      {children}
+    </OrderBridge>
+  )
+}
+
+function OrderBridge(
+  { registry, draft, children }: {
+    registry: ComponentRegistry
+    draft: ScopedValueAccess<OrderState>
+    children: React.ReactNode
+  }
+) {
+  const store = useMemo(() => scopedValueStateStore({ value: draft }), [draft])
+  const actions = useMemo(() => ({
+    submitOrder: flowAction({
+      flow: submitOrder,
+      tags: [currentOrderDraft(draft)],
+    }),
+  }), [draft])
+  const handlers = useFlowHandlers(actions)
+
+  return (
+    <JSONUIProvider registry={registry} store={store} handlers={handlers}>
+      {children}
+    </JSONUIProvider>
+  )
+}
+```
+
+The adapter exposes json-render's `StateStore` shape: JSON Pointer `get`, `set`, batched `update`,
+`getSnapshot`, server snapshot, and `subscribe`.
+
+`flowHandlers` returns json-render `ActionHandler` functions. Bare flows receive resolved
+json-render params as `rawInput`, so a flow parser can validate generated params. Use `flowAction` when
+the boundary needs to map input, set an execution name, or pass tags.
+
+`useFlowHandlers` returns stable proxy handlers that read the latest Lite context and action
+configuration. That matches json-render's action provider, which registers the handler map at provider mount.
+
+## Behavior Surface
+
+Pass the returned `handlers` to `JSONUIProvider` for json-render `on` and `watch` bindings. json-render
+continues to own event binding, action param resolution, confirmation, `onSuccess`, `onError`, and loading
+state; Lite owns the executed flows and their resources/tags/extensions.
+
+json-render also accepts `navigate`, `validationFunctions`, `functions`, and `directives`. Keep those as
+native `JSONUIProvider` props. Validation and computed functions are synchronous json-render contracts, so
+do not hide async Lite flows behind them. If they need Lite-owned data, adapt already-resolved graph values
+into sync functions at the integration boundary, or have action flows write derived results back into the
+scoped value.
+
+## Nested Slices
+
+For a nested state model, pass a selector and updater:
+
+```ts
+const store = scopedValueStateStore({
+  value: appDraft,
+  selector: (state) => state.ui,
+  updater: (next, value) => value.set({ ...value.getSnapshot(), ui: next as { count: number } }),
+})
+```
+
+The updater is required for selected slices so unrelated graph-owned state is not replaced by the
+json-render slice.
+
+## Testing
+
+Logic tests can resolve the scoped value through `createScope`, adapt it, call action handlers, and assert
+`StateStore` plus flow behavior without React. Browser observer tests should render the real json-render
+provider under `ScopeProvider` and `ExecutionContextProvider`.
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,85 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _json_render_core_store_utils = require("@json-render/core/store-utils");
+let _pumped_fn_lite_react = require("@pumped-fn/lite-react");
+let react = require("react");
+//#region src/index.ts
+function scopedValueStateStore(options) {
+	const source = options.value;
+	const selector = "selector" in options ? options.selector : (state) => state;
+	const updater = "updater" in options ? options.updater : (next, value) => value.set(next);
+	return (0, _json_render_core_store_utils.createStoreAdapter)({
+		getSnapshot: () => selector(source.getSnapshot()),
+		setSnapshot: (next) => updater(next, source),
+		subscribe(listener) {
+			let prev = selector(source.getSnapshot());
+			return source.subscribe(() => {
+				const current = selector(source.getSnapshot());
+				if (current !== prev) {
+					prev = current;
+					listener();
+					prev = selector(source.getSnapshot());
+				}
+			});
+		}
+	});
+}
+function flowAction(options) {
+	return options;
+}
+function flowHandlers(options) {
+	return Object.fromEntries(Object.entries(options.actions).map(([name, target]) => [name, flowActionHandler(options.ctx, target)]));
+}
+function useFlowHandlers(actions) {
+	const ctx = (0, _pumped_fn_lite_react.useExecutionContext)();
+	const ref = (0, react.useRef)(null);
+	if (!ref.current) ref.current = {
+		handlers: {},
+		cells: /* @__PURE__ */ new Map()
+	};
+	const { handlers, cells } = ref.current;
+	const actionNames = new Set(Object.keys(actions));
+	for (const name of Object.keys(handlers)) if (!actionNames.has(name)) {
+		delete handlers[name];
+		cells.delete(name);
+	}
+	for (const [name, target] of Object.entries(actions)) {
+		let cell = cells.get(name);
+		if (!cell) {
+			const nextCell = {
+				ctx,
+				target
+			};
+			cell = nextCell;
+			cells.set(name, nextCell);
+			handlers[name] = (params) => flowActionHandler(nextCell.ctx, nextCell.target)(params);
+		}
+		cell.ctx = ctx;
+		cell.target = target;
+	}
+	return handlers;
+}
+function flowActionHandler(ctx, target) {
+	if ("flow" in target) return (params) => {
+		if (target.input) return ctx.exec({
+			flow: target.flow,
+			input: target.input(params),
+			name: target.name,
+			tags: target.tags
+		});
+		return ctx.exec({
+			flow: target.flow,
+			rawInput: target.rawInput ? target.rawInput(params) : params,
+			name: target.name,
+			tags: target.tags
+		});
+	};
+	return (params) => ctx.exec({
+		flow: target,
+		rawInput: params
+	});
+}
+//#endregion
+exports.flowAction = flowAction;
+exports.flowHandlers = flowHandlers;
+exports.scopedValueStateStore = scopedValueStateStore;
+exports.useFlowHandlers = useFlowHandlers;

package/dist/index.d.cts

@@ -0,0 +1,44 @@
+import { ActionHandler, StateModel, StateStore } from "@json-render/core";
+import { Lite, ScopedValueAccess } from "@pumped-fn/lite-react";
+
+//#region src/index.d.ts
+type ScopedValueStateSource<State extends object> = Pick<ScopedValueAccess<State>, 'getSnapshot' | 'set' | 'subscribe'>;
+type JsonRenderActionParams = Record<string, unknown>;
+type FlowActionHandlerResult<Target> = Target extends Lite.Flow<infer Output, any> ? Output : Target extends FlowActionOptions<infer Flow> ? Lite.Utils.FlowOutput<Flow> : never;
+type FlowHandlers<Actions extends FlowActionTargets> = { [Name in keyof Actions]: ActionHandler<JsonRenderActionParams, FlowActionHandlerResult<Actions[Name]>> };
+type FlowActionTargets = Record<string, FlowActionTarget<Lite.Flow<any, any>>>;
+type FlowActionTarget<Flow extends Lite.Flow<any, any>> = Flow | FlowActionOptions<Flow>;
+interface ScopedValueStateStoreOptions<State extends object = StateModel> {
+  value: ScopedValueStateSource<State>;
+}
+interface ScopedValueStateStoreSliceOptions<State extends object> {
+  value: ScopedValueStateSource<State>;
+  selector(state: State): StateModel;
+  updater(nextState: StateModel, value: ScopedValueStateSource<State>): void;
+}
+interface FlowActionBaseOptions<Flow extends Lite.Flow<any, any>> {
+  flow: Flow;
+  name?: string;
+  tags?: Lite.Tagged<any>[];
+}
+interface FlowActionInputOptions<Flow extends Lite.Flow<any, any>> extends FlowActionBaseOptions<Flow> {
+  input(params: JsonRenderActionParams): Lite.Utils.FlowInput<Flow>;
+  rawInput?: never;
+}
+interface FlowActionRawInputOptions<Flow extends Lite.Flow<any, any>> extends FlowActionBaseOptions<Flow> {
+  rawInput?(params: JsonRenderActionParams): unknown;
+  input?: never;
+}
+type FlowActionOptions<Flow extends Lite.Flow<any, any>> = FlowActionInputOptions<Flow> | FlowActionRawInputOptions<Flow>;
+interface FlowHandlersOptions<Actions extends FlowActionTargets> {
+  ctx: Lite.ExecutionContext;
+  actions: Actions;
+}
+declare function scopedValueStateStore<State extends object>(options: ScopedValueStateStoreOptions<State>): StateStore;
+declare function scopedValueStateStore<State extends object>(options: ScopedValueStateStoreSliceOptions<State>): StateStore;
+declare function flowAction<Flow extends Lite.Flow<any, any>>(options: FlowActionOptions<Flow>): FlowActionOptions<Flow>;
+declare function flowHandlers<const Actions extends FlowActionTargets>(options: FlowHandlersOptions<Actions>): FlowHandlers<Actions>;
+declare function useFlowHandlers<const Actions extends FlowActionTargets>(actions: Actions): FlowHandlers<Actions>;
+//#endregion
+export { type FlowActionInputOptions, type FlowActionOptions, type FlowActionRawInputOptions, type FlowActionTarget, type FlowActionTargets, type FlowHandlers, type FlowHandlersOptions, type JsonRenderActionParams, type ScopedValueStateSource, type ScopedValueStateStoreOptions, type ScopedValueStateStoreSliceOptions, flowAction, flowHandlers, scopedValueStateStore, useFlowHandlers };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;KAMK,sBAAA,yBAA+C,IAAA,CAAK,iBAAA,CAAkB,KAAA;AAAA,KACtE,sBAAA,GAAyB,MAAM;AAAA,KAC/B,uBAAA,WACH,MAAA,SAAe,IAAA,CAAK,IAAA,sBAChB,MAAA,GACA,MAAA,SAAe,iBAAA,eACb,IAAA,CAAK,KAAA,CAAM,UAAA,CAAW,IAAA;AAAA,KAEzB,YAAA,iBAA6B,iBAAA,qBACjB,OAAA,GAAU,aAAA,CAAc,sBAAA,EAAwB,uBAAA,CAAwB,OAAA,CAAQ,IAAA;AAAA,KAE5F,iBAAA,GAAoB,MAAA,SAAe,gBAAA,CAAiB,IAAA,CAAK,IAAA;AAAA,KACzD,gBAAA,cAA8B,IAAA,CAAK,IAAA,cAAkB,IAAA,GAAO,iBAAA,CAAkB,IAAA;AAAA,UAEzE,4BAAA,wBAAoD,UAAA;EAC5D,KAAA,EAAO,sBAAA,CAAuB,KAAA;AAAA;AAAA,UAGtB,iCAAA;EACR,KAAA,EAAO,sBAAA,CAAuB,KAAA;EAC9B,QAAA,CAAS,KAAA,EAAO,KAAA,GAAQ,UAAA;EACxB,OAAA,CAAQ,SAAA,EAAW,UAAA,EAAY,KAAA,EAAO,sBAAA,CAAuB,KAAA;AAAA;AAAA,UAGrD,qBAAA,cAAmC,IAAA,CAAK,IAAA;EAChD,IAAA,EAAM,IAAA;EACN,IAAA;EACA,IAAA,GAAO,IAAA,CAAK,MAAA;AAAA;AAAA,UAGJ,sBAAA,cAAoC,IAAA,CAAK,IAAA,oBAAwB,qBAAA,CAAsB,IAAA;EAC/F,KAAA,CAAM,MAAA,EAAQ,sBAAA,GAAyB,IAAA,CAAK,KAAA,CAAM,SAAA,CAAU,IAAA;EAC5D,QAAA;AAAA;AAAA,UAGQ,yBAAA,cAAuC,IAAA,CAAK,IAAA,oBAAwB,qBAAA,CAAsB,IAAA;EAClG,QAAA,EAAU,MAAA,EAAQ,sBAAA;EAClB,KAAA;AAAA;AAAA,KAGG,iBAAA,cAA+B,IAAA,CAAK,IAAA,cACrC,sBAAA,CAAuB,IAAA,IACvB,yBAAA,CAA0B,IAAA;AAAA,UAEpB,mBAAA,iBAAoC,iBAAA;EAC5C,GAAA,EAAK,IAAA,CAAK,gBAAA;EACV,OAAA,EAAS,OAAA;AAAA;AAAA,iBAaF,qBAAA,sBAAA,CACP,OAAA,EAAS,4BAAA,CAA6B,KAAA,IACrC,UAAA;AAAA,iBACM,qBAAA,sBAAA,CACP,OAAA,EAAS,iCAAA,CAAkC,KAAA,IAC1C,UAAA;AAAA,iBA6BM,UAAA,cAAwB,IAAA,CAAK,IAAA,WAAA,CAAgB,OAAA,EAAS,iBAAA,CAAkB,IAAA,IAAQ,iBAAA,CAAkB,IAAA;AAAA,iBAIlG,YAAA,uBAAmC,iBAAA,CAAA,CAC1C,OAAA,EAAS,mBAAA,CAAoB,OAAA,IAC5B,YAAA,CAAa,OAAA;AAAA,iBASP,eAAA,uBAAsC,iBAAA,CAAA,CAC7C,OAAA,EAAS,OAAA,GACR,YAAA,CAAa,OAAA"}

package/dist/index.d.mts

@@ -0,0 +1,44 @@
+import { Lite, ScopedValueAccess } from "@pumped-fn/lite-react";
+import { ActionHandler, StateModel, StateStore } from "@json-render/core";
+
+//#region src/index.d.ts
+type ScopedValueStateSource<State extends object> = Pick<ScopedValueAccess<State>, 'getSnapshot' | 'set' | 'subscribe'>;
+type JsonRenderActionParams = Record<string, unknown>;
+type FlowActionHandlerResult<Target> = Target extends Lite.Flow<infer Output, any> ? Output : Target extends FlowActionOptions<infer Flow> ? Lite.Utils.FlowOutput<Flow> : never;
+type FlowHandlers<Actions extends FlowActionTargets> = { [Name in keyof Actions]: ActionHandler<JsonRenderActionParams, FlowActionHandlerResult<Actions[Name]>> };
+type FlowActionTargets = Record<string, FlowActionTarget<Lite.Flow<any, any>>>;
+type FlowActionTarget<Flow extends Lite.Flow<any, any>> = Flow | FlowActionOptions<Flow>;
+interface ScopedValueStateStoreOptions<State extends object = StateModel> {
+  value: ScopedValueStateSource<State>;
+}
+interface ScopedValueStateStoreSliceOptions<State extends object> {
+  value: ScopedValueStateSource<State>;
+  selector(state: State): StateModel;
+  updater(nextState: StateModel, value: ScopedValueStateSource<State>): void;
+}
+interface FlowActionBaseOptions<Flow extends Lite.Flow<any, any>> {
+  flow: Flow;
+  name?: string;
+  tags?: Lite.Tagged<any>[];
+}
+interface FlowActionInputOptions<Flow extends Lite.Flow<any, any>> extends FlowActionBaseOptions<Flow> {
+  input(params: JsonRenderActionParams): Lite.Utils.FlowInput<Flow>;
+  rawInput?: never;
+}
+interface FlowActionRawInputOptions<Flow extends Lite.Flow<any, any>> extends FlowActionBaseOptions<Flow> {
+  rawInput?(params: JsonRenderActionParams): unknown;
+  input?: never;
+}
+type FlowActionOptions<Flow extends Lite.Flow<any, any>> = FlowActionInputOptions<Flow> | FlowActionRawInputOptions<Flow>;
+interface FlowHandlersOptions<Actions extends FlowActionTargets> {
+  ctx: Lite.ExecutionContext;
+  actions: Actions;
+}
+declare function scopedValueStateStore<State extends object>(options: ScopedValueStateStoreOptions<State>): StateStore;
+declare function scopedValueStateStore<State extends object>(options: ScopedValueStateStoreSliceOptions<State>): StateStore;
+declare function flowAction<Flow extends Lite.Flow<any, any>>(options: FlowActionOptions<Flow>): FlowActionOptions<Flow>;
+declare function flowHandlers<const Actions extends FlowActionTargets>(options: FlowHandlersOptions<Actions>): FlowHandlers<Actions>;
+declare function useFlowHandlers<const Actions extends FlowActionTargets>(actions: Actions): FlowHandlers<Actions>;
+//#endregion
+export { type FlowActionInputOptions, type FlowActionOptions, type FlowActionRawInputOptions, type FlowActionTarget, type FlowActionTargets, type FlowHandlers, type FlowHandlersOptions, type JsonRenderActionParams, type ScopedValueStateSource, type ScopedValueStateStoreOptions, type ScopedValueStateStoreSliceOptions, flowAction, flowHandlers, scopedValueStateStore, useFlowHandlers };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;KAMK,sBAAA,yBAA+C,IAAA,CAAK,iBAAA,CAAkB,KAAA;AAAA,KACtE,sBAAA,GAAyB,MAAM;AAAA,KAC/B,uBAAA,WACH,MAAA,SAAe,IAAA,CAAK,IAAA,sBAChB,MAAA,GACA,MAAA,SAAe,iBAAA,eACb,IAAA,CAAK,KAAA,CAAM,UAAA,CAAW,IAAA;AAAA,KAEzB,YAAA,iBAA6B,iBAAA,qBACjB,OAAA,GAAU,aAAA,CAAc,sBAAA,EAAwB,uBAAA,CAAwB,OAAA,CAAQ,IAAA;AAAA,KAE5F,iBAAA,GAAoB,MAAA,SAAe,gBAAA,CAAiB,IAAA,CAAK,IAAA;AAAA,KACzD,gBAAA,cAA8B,IAAA,CAAK,IAAA,cAAkB,IAAA,GAAO,iBAAA,CAAkB,IAAA;AAAA,UAEzE,4BAAA,wBAAoD,UAAA;EAC5D,KAAA,EAAO,sBAAA,CAAuB,KAAA;AAAA;AAAA,UAGtB,iCAAA;EACR,KAAA,EAAO,sBAAA,CAAuB,KAAA;EAC9B,QAAA,CAAS,KAAA,EAAO,KAAA,GAAQ,UAAA;EACxB,OAAA,CAAQ,SAAA,EAAW,UAAA,EAAY,KAAA,EAAO,sBAAA,CAAuB,KAAA;AAAA;AAAA,UAGrD,qBAAA,cAAmC,IAAA,CAAK,IAAA;EAChD,IAAA,EAAM,IAAA;EACN,IAAA;EACA,IAAA,GAAO,IAAA,CAAK,MAAA;AAAA;AAAA,UAGJ,sBAAA,cAAoC,IAAA,CAAK,IAAA,oBAAwB,qBAAA,CAAsB,IAAA;EAC/F,KAAA,CAAM,MAAA,EAAQ,sBAAA,GAAyB,IAAA,CAAK,KAAA,CAAM,SAAA,CAAU,IAAA;EAC5D,QAAA;AAAA;AAAA,UAGQ,yBAAA,cAAuC,IAAA,CAAK,IAAA,oBAAwB,qBAAA,CAAsB,IAAA;EAClG,QAAA,EAAU,MAAA,EAAQ,sBAAA;EAClB,KAAA;AAAA;AAAA,KAGG,iBAAA,cAA+B,IAAA,CAAK,IAAA,cACrC,sBAAA,CAAuB,IAAA,IACvB,yBAAA,CAA0B,IAAA;AAAA,UAEpB,mBAAA,iBAAoC,iBAAA;EAC5C,GAAA,EAAK,IAAA,CAAK,gBAAA;EACV,OAAA,EAAS,OAAA;AAAA;AAAA,iBAaF,qBAAA,sBAAA,CACP,OAAA,EAAS,4BAAA,CAA6B,KAAA,IACrC,UAAA;AAAA,iBACM,qBAAA,sBAAA,CACP,OAAA,EAAS,iCAAA,CAAkC,KAAA,IAC1C,UAAA;AAAA,iBA6BM,UAAA,cAAwB,IAAA,CAAK,IAAA,WAAA,CAAgB,OAAA,EAAS,iBAAA,CAAkB,IAAA,IAAQ,iBAAA,CAAkB,IAAA;AAAA,iBAIlG,YAAA,uBAAmC,iBAAA,CAAA,CAC1C,OAAA,EAAS,mBAAA,CAAoB,OAAA,IAC5B,YAAA,CAAa,OAAA;AAAA,iBASP,eAAA,uBAAsC,iBAAA,CAAA,CAC7C,OAAA,EAAS,OAAA,GACR,YAAA,CAAa,OAAA"}

package/dist/index.mjs

@@ -0,0 +1,83 @@
+import { createStoreAdapter } from "@json-render/core/store-utils";
+import { useExecutionContext } from "@pumped-fn/lite-react";
+import { useRef } from "react";
+//#region src/index.ts
+function scopedValueStateStore(options) {
+	const source = options.value;
+	const selector = "selector" in options ? options.selector : (state) => state;
+	const updater = "updater" in options ? options.updater : (next, value) => value.set(next);
+	return createStoreAdapter({
+		getSnapshot: () => selector(source.getSnapshot()),
+		setSnapshot: (next) => updater(next, source),
+		subscribe(listener) {
+			let prev = selector(source.getSnapshot());
+			return source.subscribe(() => {
+				const current = selector(source.getSnapshot());
+				if (current !== prev) {
+					prev = current;
+					listener();
+					prev = selector(source.getSnapshot());
+				}
+			});
+		}
+	});
+}
+function flowAction(options) {
+	return options;
+}
+function flowHandlers(options) {
+	return Object.fromEntries(Object.entries(options.actions).map(([name, target]) => [name, flowActionHandler(options.ctx, target)]));
+}
+function useFlowHandlers(actions) {
+	const ctx = useExecutionContext();
+	const ref = useRef(null);
+	if (!ref.current) ref.current = {
+		handlers: {},
+		cells: /* @__PURE__ */ new Map()
+	};
+	const { handlers, cells } = ref.current;
+	const actionNames = new Set(Object.keys(actions));
+	for (const name of Object.keys(handlers)) if (!actionNames.has(name)) {
+		delete handlers[name];
+		cells.delete(name);
+	}
+	for (const [name, target] of Object.entries(actions)) {
+		let cell = cells.get(name);
+		if (!cell) {
+			const nextCell = {
+				ctx,
+				target
+			};
+			cell = nextCell;
+			cells.set(name, nextCell);
+			handlers[name] = (params) => flowActionHandler(nextCell.ctx, nextCell.target)(params);
+		}
+		cell.ctx = ctx;
+		cell.target = target;
+	}
+	return handlers;
+}
+function flowActionHandler(ctx, target) {
+	if ("flow" in target) return (params) => {
+		if (target.input) return ctx.exec({
+			flow: target.flow,
+			input: target.input(params),
+			name: target.name,
+			tags: target.tags
+		});
+		return ctx.exec({
+			flow: target.flow,
+			rawInput: target.rawInput ? target.rawInput(params) : params,
+			name: target.name,
+			tags: target.tags
+		});
+	};
+	return (params) => ctx.exec({
+		flow: target,
+		rawInput: params
+	});
+}
+//#endregion
+export { flowAction, flowHandlers, scopedValueStateStore, useFlowHandlers };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import { createStoreAdapter } from '@json-render/core/store-utils'\nimport type { ActionHandler, StateModel, StateStore } from '@json-render/core'\nimport { useExecutionContext } from '@pumped-fn/lite-react'\nimport type { Lite, ScopedValueAccess } from '@pumped-fn/lite-react'\nimport { useRef } from 'react'\n\ntype ScopedValueStateSource<State extends object> = Pick<ScopedValueAccess<State>, 'getSnapshot' | 'set' | 'subscribe'>\ntype JsonRenderActionParams = Record<string, unknown>\ntype FlowActionHandlerResult<Target> =\n  Target extends Lite.Flow<infer Output, any>\n    ? Output\n    : Target extends FlowActionOptions<infer Flow>\n      ? Lite.Utils.FlowOutput<Flow>\n      : never\ntype FlowHandlers<Actions extends FlowActionTargets> = {\n  [Name in keyof Actions]: ActionHandler<JsonRenderActionParams, FlowActionHandlerResult<Actions[Name]>>\n}\ntype FlowActionTargets = Record<string, FlowActionTarget<Lite.Flow<any, any>>>\ntype FlowActionTarget<Flow extends Lite.Flow<any, any>> = Flow | FlowActionOptions<Flow>\n\ninterface ScopedValueStateStoreOptions<State extends object = StateModel> {\n  value: ScopedValueStateSource<State>\n}\n\ninterface ScopedValueStateStoreSliceOptions<State extends object> {\n  value: ScopedValueStateSource<State>\n  selector(state: State): StateModel\n  updater(nextState: StateModel, value: ScopedValueStateSource<State>): void\n}\n\ninterface FlowActionBaseOptions<Flow extends Lite.Flow<any, any>> {\n  flow: Flow\n  name?: string\n  tags?: Lite.Tagged<any>[]\n}\n\ninterface FlowActionInputOptions<Flow extends Lite.Flow<any, any>> extends FlowActionBaseOptions<Flow> {\n  input(params: JsonRenderActionParams): Lite.Utils.FlowInput<Flow>\n  rawInput?: never\n}\n\ninterface FlowActionRawInputOptions<Flow extends Lite.Flow<any, any>> extends FlowActionBaseOptions<Flow> {\n  rawInput?(params: JsonRenderActionParams): unknown\n  input?: never\n}\n\ntype FlowActionOptions<Flow extends Lite.Flow<any, any>> =\n  | FlowActionInputOptions<Flow>\n  | FlowActionRawInputOptions<Flow>\n\ninterface FlowHandlersOptions<Actions extends FlowActionTargets> {\n  ctx: Lite.ExecutionContext\n  actions: Actions\n}\n\ninterface FlowActionHandlerCell {\n  ctx: Lite.ExecutionContext\n  target: FlowActionTarget<Lite.Flow<any, any>>\n}\n\ninterface FlowHandlersRef {\n  handlers: Record<string, ActionHandler<JsonRenderActionParams, unknown>>\n  cells: Map<string, FlowActionHandlerCell>\n}\n\nfunction scopedValueStateStore<State extends object>(\n  options: ScopedValueStateStoreOptions<State>\n): StateStore\nfunction scopedValueStateStore<State extends object>(\n  options: ScopedValueStateStoreSliceOptions<State>\n): StateStore\nfunction scopedValueStateStore<State extends object>(\n  options: ScopedValueStateStoreOptions<State> | ScopedValueStateStoreSliceOptions<State>\n): StateStore {\n  const source = options.value\n  const selector: (state: State) => StateModel = 'selector' in options\n    ? options.selector\n    : (state) => state as unknown as StateModel\n  const updater: (next: StateModel, value: ScopedValueStateSource<State>) => void = 'updater' in options\n    ? options.updater\n    : (next, value) => value.set(next as unknown as State)\n\n  return createStoreAdapter({\n    getSnapshot: () => selector(source.getSnapshot()),\n    setSnapshot: (next) => updater(next, source),\n    subscribe(listener) {\n      let prev = selector(source.getSnapshot())\n      return source.subscribe(() => {\n        const current = selector(source.getSnapshot())\n        if (current !== prev) {\n          prev = current\n          listener()\n          prev = selector(source.getSnapshot())\n        }\n      })\n    },\n  })\n}\n\nfunction flowAction<Flow extends Lite.Flow<any, any>>(options: FlowActionOptions<Flow>): FlowActionOptions<Flow> {\n  return options\n}\n\nfunction flowHandlers<const Actions extends FlowActionTargets>(\n  options: FlowHandlersOptions<Actions>\n): FlowHandlers<Actions> {\n  return Object.fromEntries(\n    Object.entries(options.actions).map(([name, target]) => [\n      name,\n      flowActionHandler(options.ctx, target),\n    ])\n  ) as FlowHandlers<Actions>\n}\n\nfunction useFlowHandlers<const Actions extends FlowActionTargets>(\n  actions: Actions\n): FlowHandlers<Actions> {\n  const ctx = useExecutionContext()\n  const ref = useRef<FlowHandlersRef | null>(null)\n  if (!ref.current) {\n    ref.current = {\n      handlers: {},\n      cells: new Map(),\n    }\n  }\n\n  const { handlers, cells } = ref.current\n  const actionNames = new Set(Object.keys(actions))\n\n  for (const name of Object.keys(handlers)) {\n    if (!actionNames.has(name)) {\n      delete handlers[name]\n      cells.delete(name)\n    }\n  }\n\n  for (const [name, target] of Object.entries(actions)) {\n    let cell = cells.get(name)\n    if (!cell) {\n      const nextCell = { ctx, target }\n      cell = nextCell\n      cells.set(name, nextCell)\n      handlers[name] = (params) => flowActionHandler(nextCell.ctx, nextCell.target)(params)\n    }\n    cell.ctx = ctx\n    cell.target = target\n  }\n\n  return handlers as FlowHandlers<Actions>\n}\n\nfunction flowActionHandler<Flow extends Lite.Flow<any, any>>(\n  ctx: Lite.ExecutionContext,\n  target: FlowActionTarget<Flow>\n): ActionHandler<JsonRenderActionParams, Lite.Utils.FlowOutput<Flow>> {\n  if ('flow' in target) {\n    return (params) => {\n      if (target.input) {\n        return ctx.exec<Lite.Utils.FlowOutput<Flow>, Lite.Utils.FlowInput<Flow>>({\n          flow: target.flow,\n          input: target.input(params),\n          name: target.name,\n          tags: target.tags,\n        })\n      }\n\n      return ctx.exec<Lite.Utils.FlowOutput<Flow>, Lite.Utils.FlowInput<Flow>>({\n        flow: target.flow,\n        rawInput: target.rawInput ? target.rawInput(params) : params,\n        name: target.name,\n        tags: target.tags,\n      })\n    }\n  }\n\n  return (params) => ctx.exec<Lite.Utils.FlowOutput<Flow>, Lite.Utils.FlowInput<Flow>>({\n    flow: target,\n    rawInput: params,\n  })\n}\n\nexport { flowAction, flowHandlers, scopedValueStateStore, useFlowHandlers }\nexport type {\n  FlowHandlers,\n  FlowHandlersOptions,\n  FlowActionInputOptions,\n  FlowActionOptions,\n  FlowActionRawInputOptions,\n  FlowActionTarget,\n  FlowActionTargets,\n  JsonRenderActionParams,\n  ScopedValueStateSource,\n  ScopedValueStateStoreOptions,\n  ScopedValueStateStoreSliceOptions,\n}\n"],"mappings":";;;;AAuEA,SAAS,sBACP,SACY;CACZ,MAAM,SAAS,QAAQ;CACvB,MAAM,WAAyC,cAAc,UACzD,QAAQ,YACP,UAAU;CACf,MAAM,UAA4E,aAAa,UAC3F,QAAQ,WACP,MAAM,UAAU,MAAM,IAAI,IAAwB;CAEvD,OAAO,mBAAmB;EACxB,mBAAmB,SAAS,OAAO,YAAY,CAAC;EAChD,cAAc,SAAS,QAAQ,MAAM,MAAM;EAC3C,UAAU,UAAU;GAClB,IAAI,OAAO,SAAS,OAAO,YAAY,CAAC;GACxC,OAAO,OAAO,gBAAgB;IAC5B,MAAM,UAAU,SAAS,OAAO,YAAY,CAAC;IAC7C,IAAI,YAAY,MAAM;KACpB,OAAO;KACP,SAAS;KACT,OAAO,SAAS,OAAO,YAAY,CAAC;IACtC;GACF,CAAC;EACH;CACF,CAAC;AACH;AAEA,SAAS,WAA6C,SAA2D;CAC/G,OAAO;AACT;AAEA,SAAS,aACP,SACuB;CACvB,OAAO,OAAO,YACZ,OAAO,QAAQ,QAAQ,OAAO,EAAE,KAAK,CAAC,MAAM,YAAY,CACtD,MACA,kBAAkB,QAAQ,KAAK,MAAM,CACvC,CAAC,CACH;AACF;AAEA,SAAS,gBACP,SACuB;CACvB,MAAM,MAAM,oBAAoB;CAChC,MAAM,MAAM,OAA+B,IAAI;CAC/C,IAAI,CAAC,IAAI,SACP,IAAI,UAAU;EACZ,UAAU,CAAC;EACX,uBAAO,IAAI,IAAI;CACjB;CAGF,MAAM,EAAE,UAAU,UAAU,IAAI;CAChC,MAAM,cAAc,IAAI,IAAI,OAAO,KAAK,OAAO,CAAC;CAEhD,KAAK,MAAM,QAAQ,OAAO,KAAK,QAAQ,GACrC,IAAI,CAAC,YAAY,IAAI,IAAI,GAAG;EAC1B,OAAO,SAAS;EAChB,MAAM,OAAO,IAAI;CACnB;CAGF,KAAK,MAAM,CAAC,MAAM,WAAW,OAAO,QAAQ,OAAO,GAAG;EACpD,IAAI,OAAO,MAAM,IAAI,IAAI;EACzB,IAAI,CAAC,MAAM;GACT,MAAM,WAAW;IAAE;IAAK;GAAO;GAC/B,OAAO;GACP,MAAM,IAAI,MAAM,QAAQ;GACxB,SAAS,SAAS,WAAW,kBAAkB,SAAS,KAAK,SAAS,MAAM,EAAE,MAAM;EACtF;EACA,KAAK,MAAM;EACX,KAAK,SAAS;CAChB;CAEA,OAAO;AACT;AAEA,SAAS,kBACP,KACA,QACoE;CACpE,IAAI,UAAU,QACZ,QAAQ,WAAW;EACjB,IAAI,OAAO,OACT,OAAO,IAAI,KAA8D;GACvE,MAAM,OAAO;GACb,OAAO,OAAO,MAAM,MAAM;GAC1B,MAAM,OAAO;GACb,MAAM,OAAO;EACf,CAAC;EAGH,OAAO,IAAI,KAA8D;GACvE,MAAM,OAAO;GACb,UAAU,OAAO,WAAW,OAAO,SAAS,MAAM,IAAI;GACtD,MAAM,OAAO;GACb,MAAM,OAAO;EACf,CAAC;CACH;CAGF,QAAQ,WAAW,IAAI,KAA8D;EACnF,MAAM;EACN,UAAU;CACZ,CAAC;AACH"}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@pumped-fn/lite-react-json-render",
+  "version": "0.0.0",
+  "description": "json-render state and action adapters for @pumped-fn/lite-react",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsdown --config-loader tsx",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@json-render/core": "catalog:"
+  },
+  "peerDependencies": {
+    "@pumped-fn/lite-react": "^2.3.0",
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "devDependencies": {
+    "@pumped-fn/lite": "workspace:*",
+    "@pumped-fn/lite-react": "workspace:*",
+    "@types/react": "catalog:",
+    "react": "catalog:",
+    "tsdown": "catalog:",
+    "typescript": "catalog:",
+    "vite": "catalog:",
+    "vitest": "catalog:"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "directory": "packages/lite-react-json-render",
+    "url": "git+https://github.com/pumped-fn/pumped-fn.git"
+  },
+  "keywords": [
+    "json-render",
+    "state-store",
+    "pumped-fn",
+    "lite-react",
+    "react",
+    "scoped-value"
+  ],
+  "license": "MIT"
+}