@surveystudio/node-registery 1.1.0 → 1.3.0

package/README.md

@@ -2,7 +2,7 @@
 
 Typed survey question node registry with separate entrypoints for pure logic, runner UI, and builder UI.
 
-This package is currently in early migration. It exports the first migrated node, `plainText`, while the remaining SurveyChamp question nodes are being moved into the registry.
+This package is currently in early migration. It exports migrated node logic for server runtimes and selected builder/runner UI adapters while the remaining SurveyChamp question nodes are being moved into the registry.
 
 ## Entrypoints
 
@@ -38,6 +38,13 @@ Migrated nodes:
 - `dateInput`
 - `multiInput`
 - `zipCodeInput`
+- `singleChoice` logic
+- `multipleChoice` logic
+- `dropdown` logic
+- `ranking` logic
+- `rating` logic
+- `slider` logic
+- `consent` logic
 - `plainText`
 
 The registry contract test intentionally fails until all planned question nodes are migrated.

package/dist/builder.d.mts

@@ -1,7 +1,7 @@
-export { B as BuilderRegistry, C as CompleteBuilderRegistry, N as NodeBuilder, a as NodeBuilderProps, b as NodeCanvasProps, Q as QuestionNodeDefinition, d as defineBuilderRegistry, c as defineQuestionNode } from './types-CgiAR_DF.mjs';
-import { J as JsonValue } from './coreTypes-YSpR0Oyh.mjs';
-export { N as NodeManifest, P as PropertyField, a as PropertyFieldType, S as SelectOption } from './coreTypes-YSpR0Oyh.mjs';
-import { P as PlainTextData, B as BaseTextData, M as MultiInputData, N as NumberInputData, T as TextInputData, Z as ZipCodeInputData } from './types-CjF8-OZi.mjs';
+export { B as BuilderRegistry, C as CompleteBuilderRegistry, N as NodeBuilder, a as NodeBuilderProps, b as NodeCanvasProps, Q as QuestionNodeDefinition, d as defineBuilderRegistry, c as defineQuestionNode } from './types-4zXsOMLb.mjs';
+import { J as JsonValue } from './coreTypes-CyFAym5A.mjs';
+export { N as NodeManifest, P as PropertyField, a as PropertyFieldType, S as SelectOption } from './coreTypes-CyFAym5A.mjs';
+import { P as PlainTextData, B as BaseTextData, M as MultiInputData, N as NumberInputData, T as TextInputData, Z as ZipCodeInputData } from './types-BMnck1ag.mjs';
 import 'react';
 
 declare const plainTextBuilder: {

package/dist/{coreTypes-YSpR0Oyh.d.mts → coreTypes-CyFAym5A.d.mts}

@@ -82,4 +82,4 @@ 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 NodeManifest as N, type PropertyField as P, type QuestionNodeType as Q, type SelectOption as S, type ValidationContext as V, type PropertyFieldType as a, type NodeLogic as b, type ExtractionContext as c, type NodeLogicContext as d, type ValidationResult as e, createInitialData as f, defineLogicRegistry as g, type NodeData as h, type SurveyNodeType as i, type NodeValue as j };
+export { type CompleteLogicRegistry as C, type DataType as D, type ExtractedValue as E, type JsonValue as J, type LogicRegistry as L, type NodeManifest as N, type PropertyField as P, type QuestionNodeType as Q, type SelectOption as S, type ValidationContext as V, type PropertyFieldType as a, type NodeData as b, type NodeLogic as c, type ExtractionContext as d, type NodeLogicContext as e, type ValidationResult as f, createInitialData as g, defineLogicRegistry as h, type SurveyNodeType as i, type NodeValue as j };

package/dist/logic.d.mts

@@ -1,9 +1,104 @@
-import { P as PlainTextData, a as PlainTextValue, D as DateInputData, b as TextValue, E as EmailInputData, M as MultiInputData, c as MultiInputValue, N as NumberInputData, T as TextInputData, Z as ZipCodeInputData, B as BaseTextData } from './types-CjF8-OZi.mjs';
-import { b as NodeLogic } from './coreTypes-YSpR0Oyh.mjs';
-export { C as CompleteLogicRegistry, D as DataType, E as ExtractedValue, c as ExtractionContext, L as LogicRegistry, d as NodeLogicContext, V as ValidationContext, e as ValidationResult, f as createInitialData, g as defineLogicRegistry } from './coreTypes-YSpR0Oyh.mjs';
+import { P as PlainTextData, a as PlainTextValue, D as DateInputData, b as TextValue, E as EmailInputData, M as MultiInputData, c as MultiInputValue, N as NumberInputData, T as TextInputData, Z as ZipCodeInputData, B as BaseTextData } from './types-BMnck1ag.mjs';
+import { b as NodeData, J as JsonValue, c as NodeLogic } from './coreTypes-CyFAym5A.mjs';
+export { C as CompleteLogicRegistry, D as DataType, E as ExtractedValue, d as ExtractionContext, L as LogicRegistry, e as NodeLogicContext, V as ValidationContext, f as ValidationResult, g as createInitialData, h as defineLogicRegistry } from './coreTypes-CyFAym5A.mjs';
+
+type ConditionData$2 = {
+    id: string;
+    type: "group";
+    logicType: "AND" | "OR";
+    children: JsonValue[];
+};
+type ConsentData = NodeData & {
+    label: string;
+    description: string;
+    condition: ConditionData$2;
+    checkboxLabel: string;
+    disagreeLabel?: string;
+};
+type ConsentValue = boolean;
+
+type ConditionData$1 = {
+    id: string;
+    type: "group";
+    logicType: "AND" | "OR";
+    children: JsonValue[];
+};
+type ScaleItem = NodeData & {
+    id?: string;
+    exportId?: string;
+    technicalId?: string;
+    label?: string;
+    value?: string;
+};
+type ScaleResponseMode = "single" | "multi";
+type BaseScaleData = NodeData & {
+    label: string;
+    description: string;
+    condition: ConditionData$1;
+    responseMode?: ScaleResponseMode;
+    items: ScaleItem[];
+};
+type RatingData = BaseScaleData & {
+    maxRating: number;
+};
+type SliderData = BaseScaleData & {
+    min: number;
+    max: number;
+    step: number;
+    startValue: number;
+};
+type ScaleValue = number | Record<string, number>;
+
+type ConditionData = {
+    id: string;
+    type: "group";
+    logicType: "AND" | "OR";
+    children: JsonValue[];
+};
+type ChoiceOption = NodeData & {
+    id?: string;
+    label: string;
+    value: string;
+    imageUrl?: string;
+};
+type BaseChoiceData = NodeData & {
+    label: string;
+    description: string;
+    condition: ConditionData;
+    options: ChoiceOption[];
+    randomizeOptions?: boolean;
+};
+type SingleChoiceData = BaseChoiceData & {
+    allowOther?: boolean;
+    otherLabel?: string;
+};
+type DropdownData = BaseChoiceData & {
+    searchable?: boolean;
+};
+type MultipleChoiceData = BaseChoiceData & {
+    minChoices?: number;
+    maxChoices?: number;
+};
+type RankingData = BaseChoiceData & {
+    maxRank?: number;
+    displayMode?: "drag" | "select";
+};
+type SingleChoiceValue = string;
+type MultipleChoiceValue = string[];
+type RankingValue = string[];
 
 declare const plainTextLogic: NodeLogic<"plainText", PlainTextData, PlainTextValue>;
 
+declare const consentLogic: NodeLogic<"consent", ConsentData, ConsentValue>;
+
+declare const ratingLogic: NodeLogic<"rating", RatingData, ScaleValue>;
+declare const sliderLogic: NodeLogic<"slider", SliderData, ScaleValue>;
+
+declare const singleChoiceLogic: NodeLogic<"singleChoice", SingleChoiceData, SingleChoiceValue>;
+declare const dropdownLogic: NodeLogic<"dropdown", DropdownData, SingleChoiceValue>;
+declare const multipleChoiceLogic: NodeLogic<"multipleChoice", MultipleChoiceData, MultipleChoiceValue>;
+declare const rankingLogic: NodeLogic<"ranking", RankingData, RankingValue>;
+
 declare const textInputLogic: NodeLogic<"textInput", TextInputData, TextValue>;
 declare const emailInputLogic: NodeLogic<"emailInput", EmailInputData, TextValue>;
 declare const dateInputLogic: NodeLogic<"dateInput", DateInputData, TextValue>;
@@ -18,7 +113,14 @@ declare const logicRegistry: {
     readonly dateInput: NodeLogic<"dateInput", BaseTextData, string>;
     readonly multiInput: NodeLogic<"multiInput", MultiInputData, MultiInputValue>;
     readonly zipCodeInput: NodeLogic<"zipCodeInput", ZipCodeInputData, string>;
+    readonly singleChoice: NodeLogic<"singleChoice", SingleChoiceData, string>;
+    readonly multipleChoice: NodeLogic<"multipleChoice", MultipleChoiceData, MultipleChoiceValue>;
+    readonly dropdown: NodeLogic<"dropdown", DropdownData, string>;
+    readonly ranking: NodeLogic<"ranking", RankingData, RankingValue>;
+    readonly rating: NodeLogic<"rating", RatingData, ScaleValue>;
+    readonly slider: NodeLogic<"slider", SliderData, ScaleValue>;
+    readonly consent: NodeLogic<"consent", ConsentData, boolean>;
     readonly plainText: NodeLogic<"plainText", PlainTextData, PlainTextValue>;
 };
 
-export { NodeLogic, dateInputLogic, emailInputLogic, logicRegistry, multiInputLogic, numberInputLogic, plainTextLogic, textInputLogic, zipCodeInputLogic };
+export { NodeLogic, consentLogic, dateInputLogic, dropdownLogic, emailInputLogic, logicRegistry, multiInputLogic, multipleChoiceLogic, numberInputLogic, plainTextLogic, rankingLogic, ratingLogic, singleChoiceLogic, sliderLogic, textInputLogic, zipCodeInputLogic };

package/dist/logic.mjs

@@ -67,30 +67,449 @@ var plainTextLogic = {
   ]
 };
 
-// src/nodes/textLike/manifest.ts
+// src/nodes/consent/manifest.ts
 var defaultCondition = {
   id: "root",
   type: "group",
   logicType: "AND",
   children: []
 };
+var consentDefaultData = {
+  label: "Consent",
+  description: "I agree to the terms and conditions.",
+  condition: defaultCondition,
+  checkboxLabel: "I agree",
+  disagreeLabel: "I do not agree to the terms"
+};
+
+// src/nodes/consent/logic.ts
+var normalizeConsentValue = (value) => {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (["true", "yes", "agree", "agreed", "1"].includes(normalized)) return true;
+    if (["false", "no", "disagree", "disagreed", "0"].includes(normalized)) return false;
+  }
+  if (typeof value === "number") return value !== 0;
+  return false;
+};
+var consentLogic = {
+  type: "consent",
+  dataType: "boolean",
+  defaultData: consentDefaultData,
+  defaultValue: false,
+  normalizeValue: normalizeConsentValue,
+  validate: () => ({ valid: true }),
+  extractValue: (value) => [
+    {
+      booleanValue: value,
+      textValue: value ? "Yes" : "No"
+    }
+  ]
+};
+
+// src/nodes/scale/manifest.ts
+var defaultCondition2 = {
+  id: "root",
+  type: "group",
+  logicType: "AND",
+  children: []
+};
+var baseScaleData = {
+  label: "",
+  description: "",
+  condition: defaultCondition2,
+  responseMode: "single",
+  items: []
+};
+var responseModeProperty = {
+  name: "responseMode",
+  label: "Response Mode",
+  type: "select",
+  defaultValue: "single",
+  options: [
+    { label: "Single Question", value: "single" },
+    { label: "Multiple Items", value: "multi" }
+  ]
+};
+var commonProperties = [
+  responseModeProperty,
+  { name: "label", label: "Question Label", type: "text" },
+  { name: "description", label: "Description", type: "textarea" },
+  {
+    name: "condition",
+    label: "Logic Rule",
+    type: "condition",
+    defaultValue: defaultCondition2
+  },
+  { name: "items", label: "Items", type: "options", defaultValue: [] }
+];
+var ratingDefaultData = {
+  ...baseScaleData,
+  label: "Rating",
+  maxRating: 5
+};
+var sliderDefaultData = {
+  ...baseScaleData,
+  label: "Slider / Scale",
+  min: 0,
+  max: 10,
+  step: 1,
+  startValue: 5
+};
+var ratingManifest = {
+  type: "rating",
+  label: "Rating",
+  description: "Star rating scale",
+  category: "choice",
+  dataType: "number",
+  defaultData: ratingDefaultData,
+  properties: [
+    ...commonProperties,
+    { name: "maxRating", label: "Max Stars", type: "number", defaultValue: 5 }
+  ]
+};
+var sliderManifest = {
+  type: "slider",
+  label: "Slider / Scale",
+  description: "Single or multi-item scale",
+  category: "choice",
+  dataType: "number",
+  defaultData: sliderDefaultData,
+  properties: [
+    ...commonProperties,
+    { name: "min", label: "Minimum", type: "number", defaultValue: 0 },
+    { name: "max", label: "Maximum", type: "number", defaultValue: 10 },
+    { name: "step", label: "Step", type: "number", defaultValue: 1, min: 0 },
+    { name: "startValue", label: "Start Value", type: "number", defaultValue: 5 }
+  ]
+};
+
+// src/nodes/scale/logic.ts
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var numberValue = (value) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+};
+var positiveNumber = (value) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+};
+var itemsFor = (nodeData) => Array.isArray(nodeData.items) ? nodeData.items : [];
+var inferMode = (nodeData) => {
+  if (nodeData.responseMode === "single" || nodeData.responseMode === "multi") return nodeData.responseMode;
+  return itemsFor(nodeData).length > 0 ? "multi" : "single";
+};
+var itemKey = (item) => item.exportId || item.technicalId || item.value || item.id;
+var itemLabel = (item, fallback) => item.label || fallback;
+var firstItemKey = (nodeData) => {
+  const firstItem = itemsFor(nodeData)[0];
+  return firstItem ? itemKey(firstItem) : void 0;
+};
+var normalizeScaleValue = (rawValue, nodeData) => {
+  const mode = inferMode(nodeData);
+  if (mode === "multi") {
+    if (isRecord(rawValue)) {
+      return Object.fromEntries(Object.entries(rawValue).map(([key2, value]) => [key2, numberValue(value)]));
+    }
+    const key = firstItemKey(nodeData);
+    if (key) return { [key]: numberValue(rawValue) };
+  }
+  return numberValue(rawValue);
+};
+var validateFiniteScale = (value) => {
+  if (typeof value === "number") return Number.isFinite(value) ? { valid: true } : { valid: false, error: "Please enter a valid number" };
+  const invalidKey = Object.entries(value).find(([, itemValue]) => !Number.isFinite(itemValue))?.[0];
+  return invalidKey ? { valid: false, error: `${invalidKey}: Please enter a valid number` } : { valid: true };
+};
+var validateRatingValue = (value, nodeData) => {
+  const finiteResult = validateFiniteScale(value);
+  if (!finiteResult.valid) return finiteResult;
+  const maxRating = positiveNumber(nodeData.maxRating) || 5;
+  const values = typeof value === "number" ? [value] : Object.values(value);
+  const outOfRange = values.find((itemValue) => itemValue < 1 || itemValue > maxRating);
+  return typeof outOfRange === "number" ? { valid: false, error: `Rating must be between 1 and ${maxRating}` } : { valid: true };
+};
+var validateSliderValue = (value, nodeData) => {
+  const finiteResult = validateFiniteScale(value);
+  if (!finiteResult.valid) return finiteResult;
+  const min = numberValue(nodeData.min);
+  const max = Number.isFinite(Number(nodeData.max)) ? Number(nodeData.max) : 10;
+  const values = typeof value === "number" ? [value] : Object.values(value);
+  const outOfRange = values.find((itemValue) => itemValue < min || itemValue > max);
+  return typeof outOfRange === "number" ? { valid: false, error: `Value must be between ${min} and ${max}` } : { valid: true };
+};
+var extractScaleValue = (value, nodeData) => {
+  const mode = inferMode(nodeData);
+  if (mode === "multi" && isRecord(value)) {
+    const items = itemsFor(nodeData);
+    return Object.entries(value).map(([key, itemValue]) => {
+      const item = items.find((candidate) => itemKey(candidate) === key);
+      return {
+        columnKey: key,
+        columnLabel: item ? itemLabel(item, key) : key,
+        numberValue: itemValue,
+        textValue: String(itemValue)
+      };
+    });
+  }
+  const scalarValue = typeof value === "number" ? value : 0;
+  return [{ numberValue: scalarValue, textValue: String(scalarValue) }];
+};
+var ratingLogic = {
+  type: "rating",
+  dataType: "number",
+  defaultData: ratingDefaultData,
+  defaultValue: 0,
+  normalizeValue: normalizeScaleValue,
+  validate: validateRatingValue,
+  extractValue: extractScaleValue
+};
+var sliderLogic = {
+  type: "slider",
+  dataType: "number",
+  defaultData: sliderDefaultData,
+  defaultValue: 0,
+  normalizeValue: normalizeScaleValue,
+  validate: validateSliderValue,
+  extractValue: extractScaleValue
+};
+
+// src/nodes/choice/manifest.ts
+var defaultCondition3 = {
+  id: "root",
+  type: "group",
+  logicType: "AND",
+  children: []
+};
+var baseChoiceData = {
+  label: "",
+  description: "",
+  condition: defaultCondition3,
+  options: [],
+  randomizeOptions: false
+};
+var commonProperties2 = [
+  { name: "label", label: "Question Label", type: "text" },
+  { name: "description", label: "Description", type: "textarea" },
+  {
+    name: "condition",
+    label: "Logic Rule",
+    type: "condition",
+    defaultValue: defaultCondition3
+  },
+  { name: "options", label: "Options", type: "options", defaultValue: [] },
+  { name: "bulkOptions", label: "Bulk Add (one per line)", type: "textarea", placeholder: "Option A\nOption B\nOption C..." }
+];
+var singleChoiceDefaultData = {
+  ...baseChoiceData,
+  label: "Single Choice",
+  allowOther: false,
+  otherLabel: "Other"
+};
+var dropdownDefaultData = {
+  ...baseChoiceData,
+  label: "Dropdown",
+  searchable: true
+};
+var multipleChoiceDefaultData = {
+  ...baseChoiceData,
+  label: "Multiple Choice",
+  minChoices: 0,
+  maxChoices: 0
+};
+var rankingDefaultData = {
+  ...baseChoiceData,
+  label: "Ranking",
+  maxRank: 0,
+  displayMode: "drag"
+};
+var singleChoiceManifest = {
+  type: "singleChoice",
+  label: "Single Choice",
+  description: "Select one option",
+  category: "choice",
+  dataType: "option",
+  defaultData: singleChoiceDefaultData,
+  properties: [
+    ...commonProperties2,
+    { name: "allowOther", label: "Allow Other", type: "switch", defaultValue: false },
+    { name: "otherLabel", label: "Other Label", type: "text", defaultValue: "Other" },
+    { name: "randomizeOptions", label: "Randomize Options", type: "switch", defaultValue: false }
+  ]
+};
+var dropdownManifest = {
+  type: "dropdown",
+  label: "Dropdown",
+  description: "Select from a dropdown menu",
+  category: "choice",
+  dataType: "option",
+  defaultData: dropdownDefaultData,
+  properties: [
+    ...commonProperties2,
+    { name: "searchable", label: "Searchable", type: "switch", defaultValue: true }
+  ]
+};
+var multipleChoiceManifest = {
+  type: "multipleChoice",
+  label: "Multiple Choice",
+  description: "Select multiple options",
+  category: "choice",
+  dataType: "array",
+  defaultData: multipleChoiceDefaultData,
+  properties: [
+    ...commonProperties2,
+    { name: "minChoices", label: "Minimum Choices", type: "number", defaultValue: 0 },
+    { name: "maxChoices", label: "Maximum Choices", type: "number", defaultValue: 0 },
+    { name: "randomizeOptions", label: "Randomize Options", type: "switch", defaultValue: false }
+  ]
+};
+var rankingManifest = {
+  type: "ranking",
+  label: "Ranking",
+  description: "Rank options in order",
+  category: "choice",
+  dataType: "array",
+  defaultData: rankingDefaultData,
+  properties: [
+    ...commonProperties2,
+    { name: "maxRank", label: "Maximum Rank", type: "number", defaultValue: 0 },
+    {
+      name: "displayMode",
+      label: "Display Mode",
+      type: "select",
+      defaultValue: "drag",
+      options: [
+        { label: "Drag and Drop", value: "drag" },
+        { label: "Dropdown Selection", value: "select" }
+      ]
+    }
+  ]
+};
+
+// src/nodes/choice/logic.ts
+var normalizeChoiceValue = (value) => {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return "";
+};
+var normalizeChoiceArray = (value) => {
+  if (!Array.isArray(value)) return [];
+  return value.map(normalizeChoiceValue).filter(Boolean);
+};
+var positiveNumber2 = (value) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+};
+var optionsFor = (nodeData) => Array.isArray(nodeData.options) ? nodeData.options : [];
+var optionForValue = (nodeData, value) => optionsFor(nodeData).find((option) => option.value === value || option.id === value);
+var optionLabel = (nodeData, value) => optionForValue(nodeData, value)?.label || value;
+var optionUuid = (nodeData, value) => optionForValue(nodeData, value)?.value || value;
+var validateOptionExists = (value, nodeData) => {
+  if (!value) return { valid: true };
+  if (optionsFor(nodeData).length === 0) return { valid: true };
+  return optionForValue(nodeData, value) ? { valid: true } : { valid: false, error: "Selected option is not available" };
+};
+var validateOptionArray = (value, nodeData) => {
+  if (optionsFor(nodeData).length === 0) return { valid: true };
+  const invalid = value.find((item) => !optionForValue(nodeData, item));
+  return invalid ? { valid: false, error: "Selected option is not available" } : { valid: true };
+};
+var extractSingleChoiceValue = (value, nodeData) => [
+  {
+    optionUuid: optionUuid(nodeData, value),
+    optionText: optionLabel(nodeData, value),
+    textValue: optionLabel(nodeData, value)
+  }
+];
+var singleChoiceLogic = {
+  type: "singleChoice",
+  dataType: "option",
+  defaultData: singleChoiceDefaultData,
+  defaultValue: "",
+  normalizeValue: normalizeChoiceValue,
+  validate: validateOptionExists,
+  extractValue: extractSingleChoiceValue
+};
+var dropdownLogic = {
+  type: "dropdown",
+  dataType: "option",
+  defaultData: dropdownDefaultData,
+  defaultValue: "",
+  normalizeValue: normalizeChoiceValue,
+  validate: validateOptionExists,
+  extractValue: extractSingleChoiceValue
+};
+var multipleChoiceLogic = {
+  type: "multipleChoice",
+  dataType: "array",
+  defaultData: multipleChoiceDefaultData,
+  defaultValue: [],
+  normalizeValue: normalizeChoiceArray,
+  validate: (value, nodeData) => {
+    const optionResult = validateOptionArray(value, nodeData);
+    if (!optionResult.valid) return optionResult;
+    const minChoices = positiveNumber2(nodeData.minChoices);
+    const maxChoices = positiveNumber2(nodeData.maxChoices);
+    if (minChoices && value.length < minChoices) return { valid: false, error: `Select at least ${minChoices} option(s)` };
+    if (maxChoices && value.length > maxChoices) return { valid: false, error: `Select at most ${maxChoices} option(s)` };
+    return { valid: true };
+  },
+  extractValue: (value, nodeData) => value.map((item) => ({
+    optionUuid: optionUuid(nodeData, item),
+    optionText: optionLabel(nodeData, item),
+    textValue: optionLabel(nodeData, item)
+  }))
+};
+var rankingLogic = {
+  type: "ranking",
+  dataType: "array",
+  defaultData: rankingDefaultData,
+  defaultValue: [],
+  normalizeValue: normalizeChoiceArray,
+  validate: (value, nodeData) => {
+    const optionResult = validateOptionArray(value, nodeData);
+    if (!optionResult.valid) return optionResult;
+    const maxRank = positiveNumber2(nodeData.maxRank);
+    if (maxRank && value.length > maxRank) return { valid: false, error: `Rank at most ${maxRank} option(s)` };
+    return { valid: true };
+  },
+  extractValue: (value, nodeData) => value.map((item, index) => {
+    const rank = index + 1;
+    const label = optionLabel(nodeData, item);
+    return {
+      optionUuid: optionUuid(nodeData, item),
+      optionText: label,
+      numberValue: rank,
+      textValue: `${rank}. ${label}`
+    };
+  })
+};
+
+// src/nodes/textLike/manifest.ts
+var defaultCondition4 = {
+  id: "root",
+  type: "group",
+  logicType: "AND",
+  children: []
+};
 var baseTextData = {
   label: "",
   description: "",
-  condition: defaultCondition,
+  condition: defaultCondition4,
   minChars: 0,
   maxChars: 0,
   minWords: 0,
   maxWords: 0
 };
-var commonProperties = [
+var commonProperties3 = [
   { name: "label", label: "Field Label", type: "text" },
   { name: "description", label: "Description", type: "textarea" },
   {
     name: "condition",
     label: "Logic Rule",
     type: "condition",
-    defaultValue: defaultCondition
+    defaultValue: defaultCondition4
   }
 ];
 var textLimitProperties = [
@@ -129,7 +548,7 @@ var textInputManifest = {
   dataType: "text",
   defaultData: textInputDefaultData,
   properties: [
-    ...commonProperties,
+    ...commonProperties3,
     { name: "placeholder", label: "Placeholder", type: "text", placeholder: "e.g., Type here...", defaultValue: "" },
     { name: "longAnswer", label: "Long Answer (Multi-line)", type: "switch", defaultValue: false },
     ...textLimitProperties
@@ -143,7 +562,7 @@ var numberInputManifest = {
   dataType: "number",
   defaultData: numberInputDefaultData,
   properties: [
-    ...commonProperties,
+    ...commonProperties3,
     { name: "min", label: "Minimum Value", type: "number" },
     { name: "max", label: "Maximum Value", type: "number" }
   ]
@@ -156,7 +575,7 @@ var zipCodeInputManifest = {
   dataType: "text",
   defaultData: zipCodeInputDefaultData,
   properties: [
-    ...commonProperties,
+    ...commonProperties3,
     { name: "allowedZips", label: "Allowed Zip Codes", type: "fileTextarea", placeholder: "10001, 10002, 90210... (Leave empty to allow all)", helperText: "Validation: Only users entering these zip codes can proceed. Others will be blocked." }
   ]
 };
@@ -168,7 +587,7 @@ var multiInputManifest = {
   dataType: "object",
   defaultData: multiInputDefaultData,
   properties: [
-    ...commonProperties,
+    ...commonProperties3,
     { name: "fields", label: "Input Fields", type: "options", defaultValue: [], helperText: "Value column represents input type (text, number, email)" },
     ...textLimitProperties
   ]
@@ -261,12 +680,12 @@ var numberInputLogic = {
     const limitResult = validateTextLimits(value, nodeData);
     if (!limitResult.valid) return limitResult;
     if (!value.trim()) return { valid: true };
-    const numberValue = Number(value);
-    if (Number.isNaN(numberValue)) return { valid: false, error: "Please enter a valid number" };
-    if (typeof nodeData.min === "number" && numberValue < nodeData.min) {
+    const numberValue2 = Number(value);
+    if (Number.isNaN(numberValue2)) return { valid: false, error: "Please enter a valid number" };
+    if (typeof nodeData.min === "number" && numberValue2 < nodeData.min) {
       return { valid: false, error: `Minimum value is ${nodeData.min}` };
     }
-    if (typeof nodeData.max === "number" && numberValue > nodeData.max) {
+    if (typeof nodeData.max === "number" && numberValue2 > nodeData.max) {
       return { valid: false, error: `Maximum value is ${nodeData.max}` };
     }
     return { valid: true };
@@ -337,17 +756,31 @@ var logicRegistry = defineLogicRegistry({
   dateInput: dateInputLogic,
   multiInput: multiInputLogic,
   zipCodeInput: zipCodeInputLogic,
+  singleChoice: singleChoiceLogic,
+  multipleChoice: multipleChoiceLogic,
+  dropdown: dropdownLogic,
+  ranking: rankingLogic,
+  rating: ratingLogic,
+  slider: sliderLogic,
+  consent: consentLogic,
   plainText: plainTextLogic
 });
 export {
+  consentLogic,
   createInitialData,
   dateInputLogic,
   defineLogicRegistry,
+  dropdownLogic,
   emailInputLogic,
   logicRegistry,
   multiInputLogic,
+  multipleChoiceLogic,
   numberInputLogic,
   plainTextLogic,
+  rankingLogic,
+  ratingLogic,
+  singleChoiceLogic,
+  sliderLogic,
   textInputLogic,
   zipCodeInputLogic
 };

package/dist/runner.d.mts

@@ -1,6 +1,6 @@
-export { e as CompleteRunnerRegistry, f as NodeRunner, g as NodeRunnerProps, Q as QuestionNodeDefinition, R as RunnerRegistry, c as defineQuestionNode, h as defineRunnerRegistry } from './types-CgiAR_DF.mjs';
+export { e as CompleteRunnerRegistry, f as NodeRunner, g as NodeRunnerProps, Q as QuestionNodeDefinition, R as RunnerRegistry, c as defineQuestionNode, h as defineRunnerRegistry } from './types-4zXsOMLb.mjs';
 import 'react';
-import './coreTypes-YSpR0Oyh.mjs';
+import './coreTypes-CyFAym5A.mjs';
 
 declare const plainTextRunner: {
     type: "plainText";

package/dist/{types-CgiAR_DF.d.mts → types-4zXsOMLb.d.mts}

@@ -1,5 +1,5 @@
 import { ReactNode, ComponentType } from 'react';
-import { i as SurveyNodeType, h as NodeData, Q as QuestionNodeType, j as NodeValue, N as NodeManifest, b as NodeLogic } from './coreTypes-YSpR0Oyh.mjs';
+import { i as SurveyNodeType, b as NodeData, Q as QuestionNodeType, j as NodeValue, N as NodeManifest, c as NodeLogic } from './coreTypes-CyFAym5A.mjs';
 
 interface NodeRunnerProps<TData extends NodeData = NodeData, TValue extends NodeValue = NodeValue> {
     readonly data: Readonly<TData>;

package/dist/{types-CjF8-OZi.d.mts → types-BMnck1ag.d.mts}

@@ -1,4 +1,4 @@
-import { h as NodeData, J as JsonValue } from './coreTypes-YSpR0Oyh.mjs';
+import { b as NodeData, J as JsonValue } from './coreTypes-CyFAym5A.mjs';
 
 type PlainTextData = NodeData & {
     label: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@surveystudio/node-registery",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Typed survey question node registry with split builder, runner, and logic entrypoints.",
   "main": "./dist/logic.mjs",
   "types": "./dist/logic.d.mts",