@dataverse-kit/form-runtime 0.1.0

package/dist/context.d.ts

@@ -0,0 +1,132 @@
+import React from 'react';
+import { F as FormRuntimeCapabilities } from './runtime-capabilities-Brfc7loJ.js';
+export { a as FormRuntimeConnection, b as FormRuntimePreviewContext, L as LiveDataResult, c as LookupResult, d as LookupSearchOptions, T as TimelineItem, W as WebResourceData } from './runtime-capabilities-Brfc7loJ.js';
+import { h as CalloutDefinition, ai as RelatedFormTab, A as AuditFormTab } from './control-DaXBm-52.js';
+import { F as FieldState, S as SectionState, T as TabState } from './businessRules-U1_MBgyG.js';
+import './theme-BfeZIxmZ.js';
+
+interface FormRuntimeProviderProps {
+    capabilities: FormRuntimeCapabilities;
+    children: React.ReactNode;
+}
+/**
+ * Provider wrapper. Caller supplies a `FormRuntimeCapabilities` value;
+ * descendants read it via `useFormRuntimeContext()`. Wrap the runtime's
+ * mount point (`<FormRuntime>`) with this; failing to do so causes
+ * capability-consuming controls to throw on first render.
+ */
+declare const FormRuntimeProvider: React.FC<FormRuntimeProviderProps>;
+/**
+ * Hook for runtime-internal callers that REQUIRE capabilities. Throws
+ * with a directed error message if no provider is present so the
+ * integration gap is visible at the call site (rather than a vague
+ * "Cannot read properties of null" that points at the consumer).
+ */
+declare function useFormRuntimeContext(): FormRuntimeCapabilities;
+/**
+ * Same as `useFormRuntimeContext()` but returns `null` when no provider
+ * is present. Use for OPTIONAL capability access — controls that have a
+ * sensible offline rendering (e.g. timeline, which renders a placeholder
+ * when not connected) prefer this over the throwing variant.
+ */
+declare function useOptionalFormRuntimeContext(): FormRuntimeCapabilities | null;
+
+/**
+ * CalloutsContext — exposes `form.callouts` to descendants so
+ * SectionShell's CellShell can look up the CalloutDefinition that a
+ * control's `calloutId` references without prop-drilling the array
+ * through every shell layer.
+ *
+ * The runtime emits a provider once, at the FormRuntime mount point;
+ * shells use {@link useCallout} to resolve an id to its definition (or
+ * undefined when no provider is mounted, when the array is empty, or
+ * when the id doesn't match — all of which should render the host
+ * control without callout chrome).
+ */
+
+interface CalloutsProviderProps {
+    callouts?: CalloutDefinition[];
+    children: React.ReactNode;
+}
+declare const CalloutsProvider: React.FC<CalloutsProviderProps>;
+/**
+ * Look up a callout by id. Returns undefined when no provider is
+ * mounted, when the id is undefined, or when no callout with that id
+ * exists — all should render the host control without chrome.
+ */
+declare function useCallout(id: string | undefined): CalloutDefinition | undefined;
+
+/**
+ * RuleStatesContext — exposes business-rule evaluation outputs
+ * (fieldStates / sectionStates / tabStates) to the runtime's shells so
+ * they can gate visibility and override control props (readOnly,
+ * required) at render time.
+ *
+ * The runtime does NOT own the rule engine — that's editor/host state.
+ * It only consumes pre-computed state maps. The form-builder's
+ * `useRuleExecutionStore` feeds these in via FormRuntime's `ruleStates`
+ * prop; generated apps pass equivalent maps from their host integration.
+ *
+ * Missing entries are treated as "no rule constraint" — the underlying
+ * control's own props (hidden / readOnly / required) take effect. This
+ * matches the legacy SectionPreview's fallthrough behavior.
+ */
+
+interface RuleStatesContextValue {
+    fieldStates: Record<string, FieldState>;
+    sectionStates: Record<string, SectionState>;
+    tabStates: Record<string, TabState>;
+}
+interface RuleStatesProviderProps {
+    fieldStates?: Record<string, FieldState>;
+    sectionStates?: Record<string, SectionState>;
+    tabStates?: Record<string, TabState>;
+    children: React.ReactNode;
+}
+declare const RuleStatesProvider: React.FC<RuleStatesProviderProps>;
+/**
+ * Returns the full rule-state maps. Use this when you need to walk
+ * multiple field/section ids in a single render pass (e.g. RowShell
+ * checking "is every cell in this row hidden") — avoids violating
+ * the rules of hooks by calling useFieldState in a loop.
+ */
+declare function useRuleStates(): RuleStatesContextValue;
+/** Returns the field's rule state, or undefined if no rule has set one. */
+declare function useFieldState(controlName: string | undefined): FieldState | undefined;
+/** Returns the section's rule state, or undefined if no rule has set one. */
+declare function useSectionState(sectionId: string): SectionState | undefined;
+/** Returns the tab's rule state, or undefined if no rule has set one. */
+declare function useTabState(tabId: string): TabState | undefined;
+
+/**
+ * TabContentSlotsContext — pluggable render slots for non-main tabs
+ * (related-records, audit-history). The runtime ships a placeholder
+ * for these tab types because they depend on host-specific concerns
+ * (dataverse queries, related-record metadata) that don't belong in
+ * the runtime itself.
+ *
+ * Hosts that want full fidelity (form-builder preview, generated
+ * apps) provide render functions for these slots via
+ * `TabContentSlotsProvider`. TabsShell consumes them via
+ * `useTabContentSlots()`; missing slots fall through to the
+ * placeholder.
+ *
+ * Phase 3 m6 — replaces the legacy preview's direct imports of
+ * RelatedTabPreview / AuditTabPreview without making the runtime
+ * depend on either component.
+ */
+
+interface TabContentSlots {
+    /** Render override for related-records tabs. */
+    renderRelatedTab?: (tab: RelatedFormTab) => React.ReactNode;
+    /** Render override for audit-history tabs. */
+    renderAuditTab?: (tab: AuditFormTab) => React.ReactNode;
+}
+interface TabContentSlotsProviderProps {
+    slots?: TabContentSlots;
+    children: React.ReactNode;
+}
+declare const TabContentSlotsProvider: React.FC<TabContentSlotsProviderProps>;
+declare function useTabContentSlots(): TabContentSlots;
+
+export { CalloutsProvider, type CalloutsProviderProps, FormRuntimeCapabilities, FormRuntimeProvider, type FormRuntimeProviderProps, type RuleStatesContextValue, RuleStatesProvider, type RuleStatesProviderProps, type TabContentSlots, TabContentSlotsProvider, type TabContentSlotsProviderProps, useCallout, useFieldState, useFormRuntimeContext, useOptionalFormRuntimeContext, useRuleStates, useSectionState, useTabContentSlots, useTabState };

package/dist/context.mjs

@@ -0,0 +1,113 @@
+// src/context/FormRuntimeContext.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var FormRuntimeContext = createContext(null);
+FormRuntimeContext.displayName = "FormRuntimeContext";
+var FormRuntimeProvider = ({
+  capabilities,
+  children
+}) => /* @__PURE__ */ jsx(FormRuntimeContext.Provider, { value: capabilities, children });
+function useFormRuntimeContext() {
+  const value = useContext(FormRuntimeContext);
+  if (value === null) {
+    throw new Error(
+      "[@dataverse-kit/form-runtime] useFormRuntimeContext was called outside of a <FormRuntimeProvider>. Wrap your <FormRuntime> mount with a provider that supplies FormRuntimeCapabilities (the editor app uses EditorFormRuntimeProvider; generated host code uses ServiceFactory-backed capabilities). See packages/form-runtime/src/context/FormRuntimeContext.tsx."
+    );
+  }
+  return value;
+}
+function useOptionalFormRuntimeContext() {
+  return useContext(FormRuntimeContext);
+}
+
+// src/context/CalloutsContext.tsx
+import { createContext as createContext2, useContext as useContext2, useMemo } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var EMPTY = { byId: /* @__PURE__ */ new Map() };
+var CalloutsContext = createContext2(EMPTY);
+CalloutsContext.displayName = "CalloutsContext";
+var CalloutsProvider = ({ callouts, children }) => {
+  const value = useMemo(() => {
+    if (!callouts || callouts.length === 0) return EMPTY;
+    return { byId: new Map(callouts.map((c) => [c.id, c])) };
+  }, [callouts]);
+  return /* @__PURE__ */ jsx2(CalloutsContext.Provider, { value, children });
+};
+function useCallout(id) {
+  const ctx = useContext2(CalloutsContext);
+  if (!id) return void 0;
+  return ctx.byId.get(id);
+}
+
+// src/context/RuleStatesContext.tsx
+import { createContext as createContext3, useContext as useContext3, useMemo as useMemo2 } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var EMPTY2 = {
+  fieldStates: {},
+  sectionStates: {},
+  tabStates: {}
+};
+var RuleStatesContext = createContext3(EMPTY2);
+RuleStatesContext.displayName = "RuleStatesContext";
+var RuleStatesProvider = ({
+  fieldStates,
+  sectionStates,
+  tabStates,
+  children
+}) => {
+  const value = useMemo2(
+    () => ({
+      fieldStates: fieldStates ?? {},
+      sectionStates: sectionStates ?? {},
+      tabStates: tabStates ?? {}
+    }),
+    [fieldStates, sectionStates, tabStates]
+  );
+  return /* @__PURE__ */ jsx3(RuleStatesContext.Provider, { value, children });
+};
+function useRuleStates() {
+  return useContext3(RuleStatesContext);
+}
+function useFieldState(controlName) {
+  const ctx = useContext3(RuleStatesContext);
+  if (!controlName) return void 0;
+  return ctx.fieldStates[controlName];
+}
+function useSectionState(sectionId) {
+  return useContext3(RuleStatesContext).sectionStates[sectionId];
+}
+function useTabState(tabId) {
+  return useContext3(RuleStatesContext).tabStates[tabId];
+}
+
+// src/context/TabContentSlotsContext.tsx
+import { createContext as createContext4, useContext as useContext4, useMemo as useMemo3 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var EMPTY3 = {};
+var TabContentSlotsContext = createContext4(EMPTY3);
+TabContentSlotsContext.displayName = "TabContentSlotsContext";
+var TabContentSlotsProvider = ({
+  slots,
+  children
+}) => {
+  const value = useMemo3(() => slots ?? EMPTY3, [slots]);
+  return /* @__PURE__ */ jsx4(TabContentSlotsContext.Provider, { value, children });
+};
+function useTabContentSlots() {
+  return useContext4(TabContentSlotsContext);
+}
+export {
+  CalloutsProvider,
+  FormRuntimeProvider,
+  RuleStatesProvider,
+  TabContentSlotsProvider,
+  useCallout,
+  useFieldState,
+  useFormRuntimeContext,
+  useOptionalFormRuntimeContext,
+  useRuleStates,
+  useSectionState,
+  useTabContentSlots,
+  useTabState
+};
+//# sourceMappingURL=context.mjs.map

package/dist/context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/context/FormRuntimeContext.tsx","../src/context/CalloutsContext.tsx","../src/context/RuleStatesContext.tsx","../src/context/TabContentSlotsContext.tsx"],"sourcesContent":["import React, { createContext, useContext } from 'react';\nimport type { FormRuntimeCapabilities } from '../types/runtime-capabilities';\n\n/**\n * Context that exposes editor- or host-supplied async capabilities to\n * the runtime's controls.\n *\n * Two implementations exist (Phase 1 Task 6.5 onwards):\n * - `EditorFormRuntimeProvider` in `apps/form-builder/src/contexts/` —\n *   wires capabilities to the form-builder's Zustand stores (designer,\n *   dataverse, previewRecord, gridCustomizer).\n * - Generated host code's provider (Phase 3) — wires capabilities to\n *   `IApiService` from `@dataverse-kit/api-service`.\n *\n * Per `feedback_v1_migrations`, the runtime DOES NOT define a default\n * mock or no-op provider. Controls that depend on capabilities throw if\n * the consumer hasn't wrapped them in a provider — the error names the\n * provider that's expected, so the failure points at the integration\n * gap rather than masking it with silent no-ops.\n */\nconst FormRuntimeContext = createContext<FormRuntimeCapabilities | null>(null);\n\nFormRuntimeContext.displayName = 'FormRuntimeContext';\n\nexport interface FormRuntimeProviderProps {\n  capabilities: FormRuntimeCapabilities;\n  children: React.ReactNode;\n}\n\n/**\n * Provider wrapper. Caller supplies a `FormRuntimeCapabilities` value;\n * descendants read it via `useFormRuntimeContext()`. Wrap the runtime's\n * mount point (`<FormRuntime>`) with this; failing to do so causes\n * capability-consuming controls to throw on first render.\n */\nexport const FormRuntimeProvider: React.FC<FormRuntimeProviderProps> = ({\n  capabilities,\n  children,\n}) => <FormRuntimeContext.Provider value={capabilities}>{children}</FormRuntimeContext.Provider>;\n\n/**\n * Hook for runtime-internal callers that REQUIRE capabilities. Throws\n * with a directed error message if no provider is present so the\n * integration gap is visible at the call site (rather than a vague\n * \"Cannot read properties of null\" that points at the consumer).\n */\nexport function useFormRuntimeContext(): FormRuntimeCapabilities {\n  const value = useContext(FormRuntimeContext);\n  if (value === null) {\n    throw new Error(\n      '[@dataverse-kit/form-runtime] useFormRuntimeContext was called outside of a ' +\n        '<FormRuntimeProvider>. Wrap your <FormRuntime> mount with a provider that ' +\n        'supplies FormRuntimeCapabilities (the editor app uses ' +\n        'EditorFormRuntimeProvider; generated host code uses ServiceFactory-backed ' +\n        'capabilities). See packages/form-runtime/src/context/FormRuntimeContext.tsx.',\n    );\n  }\n  return value;\n}\n\n/**\n * Same as `useFormRuntimeContext()` but returns `null` when no provider\n * is present. Use for OPTIONAL capability access — controls that have a\n * sensible offline rendering (e.g. timeline, which renders a placeholder\n * when not connected) prefer this over the throwing variant.\n */\nexport function useOptionalFormRuntimeContext(): FormRuntimeCapabilities | null {\n  return useContext(FormRuntimeContext);\n}\n","/**\n * CalloutsContext — exposes `form.callouts` to descendants so\n * SectionShell's CellShell can look up the CalloutDefinition that a\n * control's `calloutId` references without prop-drilling the array\n * through every shell layer.\n *\n * The runtime emits a provider once, at the FormRuntime mount point;\n * shells use {@link useCallout} to resolve an id to its definition (or\n * undefined when no provider is mounted, when the array is empty, or\n * when the id doesn't match — all of which should render the host\n * control without callout chrome).\n */\n\nimport React, { createContext, useContext, useMemo } from 'react';\nimport type { CalloutDefinition } from '../types';\n\ninterface CalloutsContextValue {\n  /** Map from callout id -> definition for O(1) lookup. */\n  byId: Map<string, CalloutDefinition>;\n}\n\nconst EMPTY: CalloutsContextValue = { byId: new Map() };\n\nconst CalloutsContext = createContext<CalloutsContextValue>(EMPTY);\nCalloutsContext.displayName = 'CalloutsContext';\n\nexport interface CalloutsProviderProps {\n  callouts?: CalloutDefinition[];\n  children: React.ReactNode;\n}\n\nexport const CalloutsProvider: React.FC<CalloutsProviderProps> = ({ callouts, children }) => {\n  const value = useMemo<CalloutsContextValue>(() => {\n    if (!callouts || callouts.length === 0) return EMPTY;\n    return { byId: new Map(callouts.map((c) => [c.id, c])) };\n  }, [callouts]);\n  return <CalloutsContext.Provider value={value}>{children}</CalloutsContext.Provider>;\n};\n\n/**\n * Look up a callout by id. Returns undefined when no provider is\n * mounted, when the id is undefined, or when no callout with that id\n * exists — all should render the host control without chrome.\n */\nexport function useCallout(id: string | undefined): CalloutDefinition | undefined {\n  const ctx = useContext(CalloutsContext);\n  if (!id) return undefined;\n  return ctx.byId.get(id);\n}\n","/**\n * RuleStatesContext — exposes business-rule evaluation outputs\n * (fieldStates / sectionStates / tabStates) to the runtime's shells so\n * they can gate visibility and override control props (readOnly,\n * required) at render time.\n *\n * The runtime does NOT own the rule engine — that's editor/host state.\n * It only consumes pre-computed state maps. The form-builder's\n * `useRuleExecutionStore` feeds these in via FormRuntime's `ruleStates`\n * prop; generated apps pass equivalent maps from their host integration.\n *\n * Missing entries are treated as \"no rule constraint\" — the underlying\n * control's own props (hidden / readOnly / required) take effect. This\n * matches the legacy SectionPreview's fallthrough behavior.\n */\n\nimport React, { createContext, useContext, useMemo } from 'react';\nimport type { FieldState, SectionState, TabState } from '../types/businessRules';\n\nexport interface RuleStatesContextValue {\n  fieldStates: Record<string, FieldState>;\n  sectionStates: Record<string, SectionState>;\n  tabStates: Record<string, TabState>;\n}\n\nconst EMPTY: RuleStatesContextValue = {\n  fieldStates: {},\n  sectionStates: {},\n  tabStates: {},\n};\n\nconst RuleStatesContext = createContext<RuleStatesContextValue>(EMPTY);\nRuleStatesContext.displayName = 'RuleStatesContext';\n\nexport interface RuleStatesProviderProps {\n  fieldStates?: Record<string, FieldState>;\n  sectionStates?: Record<string, SectionState>;\n  tabStates?: Record<string, TabState>;\n  children: React.ReactNode;\n}\n\nexport const RuleStatesProvider: React.FC<RuleStatesProviderProps> = ({\n  fieldStates,\n  sectionStates,\n  tabStates,\n  children,\n}) => {\n  const value = useMemo<RuleStatesContextValue>(\n    () => ({\n      fieldStates: fieldStates ?? {},\n      sectionStates: sectionStates ?? {},\n      tabStates: tabStates ?? {},\n    }),\n    [fieldStates, sectionStates, tabStates],\n  );\n  return <RuleStatesContext.Provider value={value}>{children}</RuleStatesContext.Provider>;\n};\n\n/**\n * Returns the full rule-state maps. Use this when you need to walk\n * multiple field/section ids in a single render pass (e.g. RowShell\n * checking \"is every cell in this row hidden\") — avoids violating\n * the rules of hooks by calling useFieldState in a loop.\n */\nexport function useRuleStates(): RuleStatesContextValue {\n  return useContext(RuleStatesContext);\n}\n\n/** Returns the field's rule state, or undefined if no rule has set one. */\nexport function useFieldState(controlName: string | undefined): FieldState | undefined {\n  const ctx = useContext(RuleStatesContext);\n  if (!controlName) return undefined;\n  return ctx.fieldStates[controlName];\n}\n\n/** Returns the section's rule state, or undefined if no rule has set one. */\nexport function useSectionState(sectionId: string): SectionState | undefined {\n  return useContext(RuleStatesContext).sectionStates[sectionId];\n}\n\n/** Returns the tab's rule state, or undefined if no rule has set one. */\nexport function useTabState(tabId: string): TabState | undefined {\n  return useContext(RuleStatesContext).tabStates[tabId];\n}\n","/**\n * TabContentSlotsContext — pluggable render slots for non-main tabs\n * (related-records, audit-history). The runtime ships a placeholder\n * for these tab types because they depend on host-specific concerns\n * (dataverse queries, related-record metadata) that don't belong in\n * the runtime itself.\n *\n * Hosts that want full fidelity (form-builder preview, generated\n * apps) provide render functions for these slots via\n * `TabContentSlotsProvider`. TabsShell consumes them via\n * `useTabContentSlots()`; missing slots fall through to the\n * placeholder.\n *\n * Phase 3 m6 — replaces the legacy preview's direct imports of\n * RelatedTabPreview / AuditTabPreview without making the runtime\n * depend on either component.\n */\n\nimport React, { createContext, useContext, useMemo } from 'react';\nimport type { RelatedFormTab, AuditFormTab } from '../types';\n\nexport interface TabContentSlots {\n  /** Render override for related-records tabs. */\n  renderRelatedTab?: (tab: RelatedFormTab) => React.ReactNode;\n  /** Render override for audit-history tabs. */\n  renderAuditTab?: (tab: AuditFormTab) => React.ReactNode;\n}\n\nconst EMPTY: TabContentSlots = {};\n\nconst TabContentSlotsContext = createContext<TabContentSlots>(EMPTY);\nTabContentSlotsContext.displayName = 'TabContentSlotsContext';\n\nexport interface TabContentSlotsProviderProps {\n  slots?: TabContentSlots;\n  children: React.ReactNode;\n}\n\nexport const TabContentSlotsProvider: React.FC<TabContentSlotsProviderProps> = ({\n  slots,\n  children,\n}) => {\n  const value = useMemo<TabContentSlots>(() => slots ?? EMPTY, [slots]);\n  return <TabContentSlotsContext.Provider value={value}>{children}</TabContentSlotsContext.Provider>;\n};\n\nexport function useTabContentSlots(): TabContentSlots {\n  return useContext(TabContentSlotsContext);\n}\n"],"mappings":"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","names":["createContext","useContext","jsx","createContext","useContext","useMemo","jsx","EMPTY","createContext","useContext","useMemo","jsx","EMPTY"]}