@surveystudio/node-registery 1.0.0 → 1.0.2

package/README.md

@@ -1,4 +1,4 @@
-# @survey-studio/node-registery
+# @surveystudio/node-registery
 
 Typed survey question node registry with separate entrypoints for pure logic, runner UI, and builder UI.
 
@@ -7,15 +7,27 @@ This package is currently in early migration. It exports the first migrated node
 ## Entrypoints
 
 ```ts
-import { logicRegistry } from "@survey-studio/node-registery/logic";
-import { runnerRegistry } from "@survey-studio/node-registery/runner";
-import { builderRegistry } from "@survey-studio/node-registery/builder";
+import { logicRegistry } from "@surveystudio/node-registery/logic";
+import { runnerRegistry } from "@surveystudio/node-registery/runner";
+import { builderRegistry } from "@surveystudio/node-registery/builder";
 ```
 
 Use `/logic` for Worker, export, and server runtimes. It is intentionally React-free.
 
 Use `/runner` and `/builder` only in React runtimes. React is a peer dependency and is not bundled.
 
+## Logic Pipeline
+
+Every node logic module should expose the same pure, Worker-safe pipeline:
+
+```ts
+const value = logicRegistry.plainText.normalizeValue(rawAnswer, node.data, context);
+const validation = logicRegistry.plainText.validate(value, node.data, context);
+const columns = logicRegistry.plainText.extractValue(value, node.data, context);
+```
+
+Runner APIs should persist and queue normalized values. Export/projection APIs should read normalized values through `extractValue`.
+
 ## Current Status
 
 Migrated nodes:

package/dist/builder.d.mts

@@ -1,17 +1,12 @@
-import * as react from 'react';
-import { CSSProperties } from 'react';
-import { i as NodeBuilderProps, P as PlainTextData, j as NodeCanvasProps, J as JsonValue } from './types-DJePy6HU.mjs';
-export { B as BuilderRegistry, k as CompleteBuilderRegistry, l as NodeBuilder, m as NodeManifest, n as PropertyField, o as PropertyFieldType, Q as QuestionNodeDefinition, S as SelectOption, p as defineBuilderRegistry, c as defineQuestionNode } from './types-DJePy6HU.mjs';
+export { B as BuilderRegistry, c as CompleteBuilderRegistry, e as NodeBuilder, f as NodeBuilderProps, g as NodeCanvasProps, Q as QuestionNodeDefinition, h as defineBuilderRegistry, d as defineQuestionNode } from './types-BpvjaHAP.mjs';
+import { J as JsonValue } from './coreTypes-D-1hYIe5.mjs';
+export { f as NodeManifest, P as PropertyField, g as PropertyFieldType, S as SelectOption } from './coreTypes-D-1hYIe5.mjs';
+import { P as PlainTextData } from './types-D78Zx0gX.mjs';
+import 'react';
 
-declare function PlainTextBuilderPreview({ data }: NodeCanvasProps<PlainTextData>): react.DetailedReactHTMLElement<{
-    style: CSSProperties;
-}, HTMLElement>;
-declare function PlainTextSettings(_props: NodeBuilderProps<PlainTextData>): null;
 declare const plainTextBuilder: {
     type: "plainText";
     label: string;
-    SettingsComponent: typeof PlainTextSettings;
-    CanvasComponent: typeof PlainTextBuilderPreview;
 };
 
 declare const plainTextManifest: {
@@ -57,9 +52,7 @@ declare const builderRegistry: {
     readonly plainText: {
         type: "plainText";
         label: string;
-        SettingsComponent: typeof PlainTextSettings;
-        CanvasComponent: typeof PlainTextBuilderPreview;
     };
 };
 
-export { NodeBuilderProps, NodeCanvasProps, builderRegistry, plainTextBuilder, plainTextManifest };
+export { builderRegistry, plainTextBuilder, plainTextManifest };

package/dist/builder.mjs

@@ -7,68 +7,9 @@ function defineBuilderRegistry(registry) {
 }
 
 // src/nodes/plainText/builder.ts
-import { createElement } from "react";
-var shellStyle = {
-  display: "grid",
-  gap: "12px",
-  minWidth: "220px"
-};
-var titleStyle = {
-  color: "#111827",
-  fontSize: "14px",
-  fontWeight: 600,
-  lineHeight: 1.3,
-  margin: 0
-};
-var descriptionStyle = {
-  background: "#f3f4f6",
-  borderRadius: "6px",
-  color: "#4b5563",
-  fontSize: "12px",
-  lineHeight: 1.45,
-  margin: 0,
-  maxHeight: "96px",
-  overflow: "hidden",
-  padding: "8px",
-  whiteSpace: "pre-wrap"
-};
-var footerStyle = {
-  display: "flex",
-  justifyContent: "flex-end"
-};
-var buttonStyle = {
-  background: "#111827",
-  border: 0,
-  borderRadius: "6px",
-  color: "#ffffff",
-  fontSize: "12px",
-  fontWeight: 500,
-  padding: "4px 10px"
-};
-function PlainTextBuilderPreview({ data }) {
-  const label = data.label || "Info Screen";
-  const description = data.description || "No content provided...";
-  const buttonLabel = data.buttonLabel || "Continue";
-  return createElement(
-    "div",
-    { style: shellStyle },
-    createElement("p", { style: titleStyle }, label),
-    createElement("p", { style: descriptionStyle }, description),
-    createElement(
-      "div",
-      { style: footerStyle },
-      createElement("button", { disabled: true, style: buttonStyle, type: "button" }, buttonLabel)
-    )
-  );
-}
-function PlainTextSettings(_props) {
-  return null;
-}
 var plainTextBuilder = {
   type: "plainText",
-  label: "Info / Text",
-  SettingsComponent: PlainTextSettings,
-  CanvasComponent: PlainTextBuilderPreview
+  label: "Info / Text"
 };
 
 // src/nodes/plainText/manifest.ts

package/dist/coreTypes-D-1hYIe5.d.mts

@@ -0,0 +1,85 @@
+declare const QUESTION_NODE_TYPES: readonly ["textInput", "numberInput", "emailInput", "dateInput", "multiInput", "zipCodeInput", "singleChoice", "multipleChoice", "dropdown", "ranking", "cascadingChoice", "matrixChoice", "rating", "slider", "consent", "captcha", "image", "video", "audio", "plainText", "emojiRating"];
+declare const FLOW_NODE_TYPES: readonly ["start", "end", "branch", "validation"];
+type QuestionNodeType = (typeof QUESTION_NODE_TYPES)[number];
+type FlowNodeType = (typeof FLOW_NODE_TYPES)[number];
+type SurveyNodeType = QuestionNodeType | FlowNodeType;
+type NodeCategory = "input" | "choice" | "logic" | "media" | "flow";
+type PrimitiveValue = string | number | boolean | null;
+type JsonValue = PrimitiveValue | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type NodeData = Record<string, JsonValue | undefined>;
+type NodeValue = JsonValue | undefined;
+type DataType = "text" | "number" | "boolean" | "option" | "array" | "object" | "none";
+type PropertyFieldType = "text" | "textarea" | "number" | "switch" | "select" | "color" | "options" | "condition" | "stepBuilder" | "fileTextarea" | "file" | "files" | "emojiOptions";
+interface SelectOption {
+    readonly label: string;
+    readonly value: string;
+}
+interface PropertyField<TData extends NodeData = NodeData> {
+    readonly name: keyof TData & string;
+    readonly label: string;
+    readonly type: PropertyFieldType;
+    readonly placeholder?: string;
+    readonly helperText?: string;
+    readonly defaultValue?: JsonValue;
+    readonly options?: readonly SelectOption[];
+    readonly visible?: (data: Readonly<TData>) => boolean;
+    readonly min?: number;
+    readonly max?: number;
+}
+interface NodeManifest<TType extends SurveyNodeType = SurveyNodeType, TData extends NodeData = NodeData> {
+    readonly type: TType;
+    readonly label: string;
+    readonly description: string;
+    readonly category: NodeCategory;
+    readonly dataType: DataType;
+    readonly defaultData: Readonly<TData>;
+    readonly properties: readonly PropertyField<TData>[];
+}
+interface ValidationResult {
+    readonly valid: boolean;
+    readonly error?: string;
+}
+interface NodeLogicContext<TType extends SurveyNodeType = SurveyNodeType> {
+    readonly nodeId: string;
+    readonly nodeType: TType;
+    readonly answerKey?: string;
+}
+interface ValidationContext<TType extends SurveyNodeType = SurveyNodeType> extends NodeLogicContext<TType> {
+    readonly mode?: "LIVE" | "TEST";
+}
+interface ExtractedValue {
+    readonly questionId?: string;
+    readonly columnKey?: string;
+    readonly columnLabel?: string;
+    readonly textValue?: string;
+    readonly numberValue?: number;
+    readonly booleanValue?: boolean;
+    readonly optionUuid?: string;
+    readonly optionText?: string;
+    readonly arrayValue?: readonly JsonValue[];
+    readonly objectValue?: Readonly<Record<string, JsonValue>>;
+    readonly metadata?: Readonly<Record<string, JsonValue>>;
+}
+interface ExtractionContext<TType extends SurveyNodeType = SurveyNodeType> extends NodeLogicContext<TType> {
+    readonly questionLabel?: string;
+}
+interface NodeLogic<TType extends SurveyNodeType = SurveyNodeType, TData extends NodeData = NodeData, TValue extends NodeValue = NodeValue> {
+    readonly type: TType;
+    readonly dataType: DataType;
+    readonly defaultData: Readonly<TData>;
+    readonly defaultValue?: TValue;
+    normalizeValue(rawValue: unknown, nodeData: Readonly<TData>, context: NodeLogicContext<TType>): TValue;
+    validate(value: TValue, nodeData: Readonly<TData>, context: ValidationContext<TType>): ValidationResult;
+    extractValue(value: TValue, nodeData: Readonly<TData>, context: ExtractionContext<TType>): readonly ExtractedValue[];
+}
+type CompleteLogicRegistry<TType extends QuestionNodeType = QuestionNodeType> = Readonly<Record<TType, NodeLogic<TType, NodeData, NodeValue>>>;
+type LogicRegistry<TType extends SurveyNodeType = SurveyNodeType> = Readonly<Partial<{
+    [K in TType]: NodeLogic<K, NodeData, NodeValue>;
+}>>;
+type RegistryKeySet = Readonly<Partial<Record<SurveyNodeType, unknown>>>;
+declare function defineLogicRegistry<const TRegistry extends RegistryKeySet>(registry: TRegistry): TRegistry;
+declare function createInitialData<TData extends NodeData>(manifest: NodeManifest<SurveyNodeType, TData>): TData;
+
+export { type CompleteLogicRegistry as C, type DataType as D, type ExtractedValue as E, type JsonValue as J, type LogicRegistry as L, type NodeLogic as N, type PropertyField as P, type QuestionNodeType as Q, type SelectOption as S, type ValidationContext as V, type ExtractionContext as a, type NodeLogicContext as b, type ValidationResult as c, createInitialData as d, defineLogicRegistry as e, type NodeManifest as f, type PropertyFieldType as g, type NodeData as h, type SurveyNodeType as i, type NodeValue as j };

package/dist/logic.d.mts

@@ -1,6 +1,5 @@
-import { P as PlainTextData, a as PlainTextValue } from './types-DJePy6HU.mjs';
-export { C as CompleteLogicRegistry, D as DataType, E as ExtractedValue, b as ExtractionContext, L as LogicRegistry, N as NodeLogic, Q as QuestionNodeDefinition, V as ValidationResult, d as defineLogicRegistry, c as defineQuestionNode } from './types-DJePy6HU.mjs';
-import 'react';
+import { P as PlainTextData, a as PlainTextValue } from './types-D78Zx0gX.mjs';
+export { C as CompleteLogicRegistry, D as DataType, E as ExtractedValue, a as ExtractionContext, L as LogicRegistry, N as NodeLogic, b as NodeLogicContext, V as ValidationContext, c as ValidationResult, d as createInitialData, e as defineLogicRegistry } from './coreTypes-D-1hYIe5.mjs';
 
 declare const plainTextLogic: {
     type: "plainText";
@@ -9,6 +8,7 @@ declare const plainTextLogic: {
     defaultValue: {
         viewed: false;
     };
+    normalizeValue: (value: unknown) => PlainTextValue;
     validate: () => {
         valid: true;
     };
@@ -27,6 +27,7 @@ declare const logicRegistry: {
         defaultValue: {
             viewed: false;
         };
+        normalizeValue: (value: unknown) => PlainTextValue;
         validate: () => {
             valid: true;
         };

package/dist/logic.mjs

@@ -1,10 +1,10 @@
-// src/types.ts
-function defineQuestionNode(definition) {
-  return definition;
-}
+// src/coreTypes.ts
 function defineLogicRegistry(registry) {
   return registry;
 }
+function createInitialData(manifest) {
+  return { ...manifest.defaultData };
+}
 
 // src/nodes/plainText/manifest.ts
 var plainTextDefaultData = {
@@ -45,17 +45,24 @@ var plainTextManifest = {
 };
 
 // src/nodes/plainText/logic.ts
+var normalizePlainTextValue = (value) => {
+  if (!value || typeof value !== "object") {
+    return { viewed: false };
+  }
+  return { viewed: Boolean(value.viewed) };
+};
 var plainTextLogic = {
   type: "plainText",
   dataType: "none",
   defaultData: plainTextDefaultData,
   defaultValue: { viewed: false },
+  normalizeValue: (value) => normalizePlainTextValue(value),
   validate: () => ({ valid: true }),
   extractValue: (value) => [
     {
       columnKey: "viewed",
       columnLabel: "Viewed",
-      booleanValue: Boolean(value?.viewed)
+      booleanValue: Boolean(value.viewed)
     }
   ]
 };
@@ -65,8 +72,8 @@ var logicRegistry = defineLogicRegistry({
   plainText: plainTextLogic
 });
 export {
+  createInitialData,
   defineLogicRegistry,
-  defineQuestionNode,
   logicRegistry,
   plainTextLogic
 };

package/dist/runner.d.mts

@@ -1,21 +1,15 @@
-import * as react from 'react';
-import { CSSProperties } from 'react';
-import { e as NodeRunnerProps, P as PlainTextData, a as PlainTextValue } from './types-DJePy6HU.mjs';
-export { f as CompleteRunnerRegistry, g as NodeRunner, Q as QuestionNodeDefinition, R as RunnerRegistry, c as defineQuestionNode, h as defineRunnerRegistry } from './types-DJePy6HU.mjs';
+export { C as CompleteRunnerRegistry, N as NodeRunner, a as NodeRunnerProps, Q as QuestionNodeDefinition, R as RunnerRegistry, d as defineQuestionNode, b as defineRunnerRegistry } from './types-BpvjaHAP.mjs';
+import 'react';
+import './coreTypes-D-1hYIe5.mjs';
 
-declare function PlainTextRunnerView({ data, onChange, onNext, isActive, }: NodeRunnerProps<PlainTextData, PlainTextValue>): react.DetailedReactHTMLElement<{
-    style: CSSProperties;
-}, HTMLElement>;
 declare const plainTextRunner: {
     type: "plainText";
-    Component: typeof PlainTextRunnerView;
 };
 
 declare const runnerRegistry: {
     readonly plainText: {
         type: "plainText";
-        Component: typeof PlainTextRunnerView;
     };
 };
 
-export { NodeRunnerProps, plainTextRunner, runnerRegistry };
+export { plainTextRunner, runnerRegistry };

package/dist/runner.mjs

@@ -7,67 +7,8 @@ function defineRunnerRegistry(registry) {
 }
 
 // src/nodes/plainText/runner.ts
-import { createElement } from "react";
-var shellStyle = {
-  display: "grid",
-  gap: "24px",
-  maxWidth: "576px",
-  padding: "16px 0",
-  width: "100%"
-};
-var descriptionStyle = {
-  color: "#334155",
-  fontSize: "18px",
-  lineHeight: 1.65,
-  margin: 0,
-  whiteSpace: "pre-wrap"
-};
-var buttonStyle = {
-  alignItems: "center",
-  background: "#111827",
-  border: 0,
-  borderRadius: "999px",
-  color: "#ffffff",
-  cursor: "pointer",
-  display: "inline-flex",
-  fontSize: "15px",
-  fontWeight: 600,
-  gap: "8px",
-  justifySelf: "start",
-  padding: "12px 24px"
-};
-function PlainTextRunnerView({
-  data,
-  onChange,
-  onNext,
-  isActive
-}) {
-  const description = data.description || "No description provided...";
-  const buttonLabel = data.buttonLabel || "Continue";
-  const children = [createElement("p", { key: "description", style: descriptionStyle }, description)];
-  if (isActive) {
-    children.push(
-      createElement(
-        "button",
-        {
-          key: "button",
-          onClick: () => {
-            onChange({ viewed: true });
-            onNext?.();
-          },
-          style: buttonStyle,
-          type: "button"
-        },
-        buttonLabel,
-        " ->"
-      )
-    );
-  }
-  return createElement("div", { style: shellStyle }, children);
-}
 var plainTextRunner = {
-  type: "plainText",
-  Component: PlainTextRunnerView
+  type: "plainText"
 };
 
 // src/runner/index.ts

package/dist/types-BpvjaHAP.d.mts

@@ -0,0 +1,51 @@
+import { ComponentType, ReactNode } from 'react';
+import { Q as QuestionNodeType, i as SurveyNodeType, h as NodeData, j as NodeValue, f as NodeManifest, N as NodeLogic } from './coreTypes-D-1hYIe5.mjs';
+
+interface NodeRunnerProps<TData extends NodeData = NodeData, TValue extends NodeValue = NodeValue> {
+    readonly data: Readonly<TData>;
+    readonly value: TValue;
+    readonly onChange: (newValue: TValue) => void;
+    readonly onNext?: () => void;
+    readonly error?: string;
+    readonly isActive?: boolean;
+}
+interface NodeRunner<TType extends SurveyNodeType = SurveyNodeType, TData extends NodeData = NodeData, TValue extends NodeValue = NodeValue> {
+    readonly type: TType;
+    readonly Component?: ComponentType<NodeRunnerProps<TData, TValue>>;
+}
+interface NodeBuilderProps<TData extends NodeData = NodeData> {
+    readonly data: Readonly<TData>;
+    readonly onChange: (newData: TData) => void;
+}
+interface NodeCanvasProps<TData extends NodeData = NodeData> {
+    readonly id: string;
+    readonly type: SurveyNodeType;
+    readonly data: Readonly<TData>;
+    readonly selected?: boolean;
+}
+interface NodeBuilder<TType extends SurveyNodeType = SurveyNodeType, TData extends NodeData = NodeData> {
+    readonly type: TType;
+    readonly label: string;
+    readonly icon?: ReactNode;
+    readonly SettingsComponent?: ComponentType<NodeBuilderProps<TData>>;
+    readonly CanvasComponent?: ComponentType<NodeCanvasProps<TData>>;
+}
+interface QuestionNodeDefinition<TType extends QuestionNodeType = QuestionNodeType, TData extends NodeData = NodeData, TValue extends NodeValue = NodeValue> {
+    readonly manifest: NodeManifest<TType, TData>;
+    readonly logic: NodeLogic<TType, TData, TValue>;
+    readonly builder: NodeBuilder<TType, TData>;
+    readonly runner: NodeRunner<TType, TData, TValue>;
+}
+type CompleteBuilderRegistry<TType extends QuestionNodeType = QuestionNodeType> = Readonly<Record<TType, NodeBuilder<TType, NodeData>>>;
+type CompleteRunnerRegistry<TType extends QuestionNodeType = QuestionNodeType> = Readonly<Record<TType, NodeRunner<TType, NodeData, NodeValue>>>;
+type BuilderRegistry<TType extends SurveyNodeType = SurveyNodeType> = Readonly<Partial<{
+    [K in TType]: NodeBuilder<K, NodeData>;
+}>>;
+type RunnerRegistry<TType extends SurveyNodeType = SurveyNodeType> = Readonly<Partial<{
+    [K in TType]: NodeRunner<K, NodeData, NodeValue>;
+}>>;
+declare function defineQuestionNode<const TType extends QuestionNodeType, TData extends NodeData, TValue extends NodeValue>(definition: QuestionNodeDefinition<TType, TData, TValue>): QuestionNodeDefinition<TType, TData, TValue>;
+declare function defineBuilderRegistry<const TRegistry extends Readonly<Partial<Record<SurveyNodeType, unknown>>>>(registry: TRegistry): TRegistry;
+declare function defineRunnerRegistry<const TRegistry extends Readonly<Partial<Record<SurveyNodeType, unknown>>>>(registry: TRegistry): TRegistry;
+
+export { type BuilderRegistry as B, type CompleteRunnerRegistry as C, type NodeRunner as N, type QuestionNodeDefinition as Q, type RunnerRegistry as R, type NodeRunnerProps as a, defineRunnerRegistry as b, type CompleteBuilderRegistry as c, defineQuestionNode as d, type NodeBuilder as e, type NodeBuilderProps as f, type NodeCanvasProps as g, defineBuilderRegistry as h };

package/dist/types-D78Zx0gX.d.mts

@@ -0,0 +1,18 @@
+import { h as NodeData, J as JsonValue } from './coreTypes-D-1hYIe5.mjs';
+
+type PlainTextData = NodeData & {
+    label: string;
+    description: string;
+    buttonLabel: string;
+    condition: {
+        id: string;
+        type: "group";
+        logicType: "AND" | "OR";
+        children: JsonValue[];
+    };
+};
+type PlainTextValue = {
+    viewed: boolean;
+};
+
+export type { PlainTextData as P, PlainTextValue as a };