@surveystudio/node-registery 1.0.2 → 1.2.0

package/dist/logic.mjs

@@ -67,13 +67,677 @@ var plainTextLogic = {
   ]
 };
 
+// src/nodes/scale/manifest.ts
+var defaultCondition = {
+  id: "root",
+  type: "group",
+  logicType: "AND",
+  children: []
+};
+var baseScaleData = {
+  label: "",
+  description: "",
+  condition: defaultCondition,
+  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: defaultCondition
+  },
+  { 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 defaultCondition2 = {
+  id: "root",
+  type: "group",
+  logicType: "AND",
+  children: []
+};
+var baseChoiceData = {
+  label: "",
+  description: "",
+  condition: defaultCondition2,
+  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: defaultCondition2
+  },
+  { 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 defaultCondition3 = {
+  id: "root",
+  type: "group",
+  logicType: "AND",
+  children: []
+};
+var baseTextData = {
+  label: "",
+  description: "",
+  condition: defaultCondition3,
+  minChars: 0,
+  maxChars: 0,
+  minWords: 0,
+  maxWords: 0
+};
+var commonProperties3 = [
+  { name: "label", label: "Field Label", type: "text" },
+  { name: "description", label: "Description", type: "textarea" },
+  {
+    name: "condition",
+    label: "Logic Rule",
+    type: "condition",
+    defaultValue: defaultCondition3
+  }
+];
+var textLimitProperties = [
+  { name: "minChars", label: "Min Characters", type: "number", helperText: "Requires at least this many characters.", defaultValue: 0 },
+  { name: "maxChars", label: "Max Characters", type: "number", helperText: "Limits total characters. 0 or empty for no limit.", defaultValue: 0 },
+  { name: "minWords", label: "Min Words", type: "number", helperText: "Requires at least this many words.", defaultValue: 0 },
+  { name: "maxWords", label: "Max Words", type: "number", helperText: "Limits total words. 0 or empty for no limit.", defaultValue: 0 }
+];
+var createBaseData = (label) => ({
+  ...baseTextData,
+  label
+});
+var textInputDefaultData = {
+  ...createBaseData("Text Answer"),
+  placeholder: "",
+  longAnswer: false
+};
+var emailInputDefaultData = createBaseData("Email");
+var dateInputDefaultData = createBaseData("Date Picker");
+var numberInputDefaultData = {
+  ...createBaseData("Number")
+};
+var zipCodeInputDefaultData = {
+  ...createBaseData("Accepted Zip Codes"),
+  allowedZips: ""
+};
+var multiInputDefaultData = {
+  ...createBaseData("Multi-Input"),
+  fields: []
+};
+var textInputManifest = {
+  type: "textInput",
+  label: "Text Answer",
+  description: "Capture text responses",
+  category: "input",
+  dataType: "text",
+  defaultData: textInputDefaultData,
+  properties: [
+    ...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
+  ]
+};
+var numberInputManifest = {
+  type: "numberInput",
+  label: "Number",
+  description: "Input for numerical values",
+  category: "input",
+  dataType: "number",
+  defaultData: numberInputDefaultData,
+  properties: [
+    ...commonProperties3,
+    { name: "min", label: "Minimum Value", type: "number" },
+    { name: "max", label: "Maximum Value", type: "number" }
+  ]
+};
+var zipCodeInputManifest = {
+  type: "zipCodeInput",
+  label: "Accepted Zip Codes",
+  description: "Validate against a list of zip codes",
+  category: "input",
+  dataType: "text",
+  defaultData: zipCodeInputDefaultData,
+  properties: [
+    ...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." }
+  ]
+};
+var multiInputManifest = {
+  type: "multiInput",
+  label: "Multi-Input",
+  description: "Multiple fields in one screen",
+  category: "input",
+  dataType: "object",
+  defaultData: multiInputDefaultData,
+  properties: [
+    ...commonProperties3,
+    { name: "fields", label: "Input Fields", type: "options", defaultValue: [], helperText: "Value column represents input type (text, number, email)" },
+    ...textLimitProperties
+  ]
+};
+
+// src/nodes/textLike/logic.ts
+var normalizeTextValue = (value) => {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return "";
+};
+var normalizeMultiInputValue = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => [key, normalizeTextValue(item)])
+  );
+};
+var numberLimit = (value) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+};
+var countWords = (value) => value.trim().split(/\s+/).filter(Boolean).length;
+var validateTextLimits = (value, nodeData) => {
+  const minChars = numberLimit(nodeData.minChars);
+  const maxChars = numberLimit(nodeData.maxChars);
+  const minWords = numberLimit(nodeData.minWords);
+  const maxWords = numberLimit(nodeData.maxWords);
+  if (minChars && value.length < minChars) {
+    return { valid: false, error: `Minimum character requirement not met (${value.length}/${minChars})` };
+  }
+  if (maxChars && value.length > maxChars) {
+    return { valid: false, error: `Character limit exceeded (${value.length}/${maxChars})` };
+  }
+  const wordCount = countWords(value);
+  if (minWords && wordCount < minWords) {
+    return { valid: false, error: `Minimum word requirement not met (${wordCount}/${minWords})` };
+  }
+  if (maxWords && wordCount > maxWords) {
+    return { valid: false, error: `Word limit exceeded (${wordCount}/${maxWords})` };
+  }
+  return { valid: true };
+};
+var extractTextValue = (value) => [
+  {
+    columnKey: "value",
+    columnLabel: "Value",
+    textValue: value
+  }
+];
+var emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var textInputLogic = {
+  type: "textInput",
+  dataType: "text",
+  defaultData: textInputDefaultData,
+  defaultValue: "",
+  normalizeValue: normalizeTextValue,
+  validate: validateTextLimits,
+  extractValue: extractTextValue
+};
+var emailInputLogic = {
+  type: "emailInput",
+  dataType: "text",
+  defaultData: emailInputDefaultData,
+  defaultValue: "",
+  normalizeValue: normalizeTextValue,
+  validate: (value, nodeData) => {
+    const limitResult = validateTextLimits(value, nodeData);
+    if (!limitResult.valid) return limitResult;
+    if (value.trim() && !emailRegex.test(value)) return { valid: false, error: "Please enter a valid email address" };
+    return { valid: true };
+  },
+  extractValue: extractTextValue
+};
+var dateInputLogic = {
+  type: "dateInput",
+  dataType: "text",
+  defaultData: dateInputDefaultData,
+  defaultValue: "",
+  normalizeValue: normalizeTextValue,
+  validate: validateTextLimits,
+  extractValue: extractTextValue
+};
+var numberInputLogic = {
+  type: "numberInput",
+  dataType: "number",
+  defaultData: numberInputDefaultData,
+  defaultValue: "",
+  normalizeValue: normalizeTextValue,
+  validate: (value, nodeData) => {
+    const limitResult = validateTextLimits(value, nodeData);
+    if (!limitResult.valid) return limitResult;
+    if (!value.trim()) return { valid: true };
+    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" && numberValue2 > nodeData.max) {
+      return { valid: false, error: `Maximum value is ${nodeData.max}` };
+    }
+    return { valid: true };
+  },
+  extractValue: (value) => [
+    value.trim() ? {
+      columnKey: "value",
+      columnLabel: "Value",
+      textValue: value,
+      numberValue: Number(value)
+    } : {
+      columnKey: "value",
+      columnLabel: "Value",
+      textValue: value
+    }
+  ]
+};
+var parseZipList = (value) => value.split(/[\s,]+/).map((item) => item.trim()).filter(Boolean);
+var zipCodeInputLogic = {
+  type: "zipCodeInput",
+  dataType: "text",
+  defaultData: zipCodeInputDefaultData,
+  defaultValue: "",
+  normalizeValue: normalizeTextValue,
+  validate: (value, nodeData) => {
+    const limitResult = validateTextLimits(value, nodeData);
+    if (!limitResult.valid) return limitResult;
+    const allowedZips = parseZipList(String(nodeData.allowedZips || ""));
+    if (allowedZips.length > 0 && value.trim() && !allowedZips.includes(value.trim())) {
+      return { valid: false, error: "Zip code is not accepted" };
+    }
+    return { valid: true };
+  },
+  extractValue: extractTextValue
+};
+var multiInputLogic = {
+  type: "multiInput",
+  dataType: "object",
+  defaultData: multiInputDefaultData,
+  defaultValue: {},
+  normalizeValue: normalizeMultiInputValue,
+  validate: (value, nodeData) => {
+    for (const [fieldId, fieldValue] of Object.entries(value)) {
+      const limitResult = validateTextLimits(fieldValue, nodeData);
+      if (!limitResult.valid) return { valid: false, error: `${fieldId}: ${limitResult.error}` };
+    }
+    return { valid: true };
+  },
+  extractValue: (value, nodeData) => {
+    const fields = Array.isArray(nodeData.fields) ? nodeData.fields : [];
+    return Object.entries(value).map(([fieldId, fieldValue]) => {
+      const field = fields.find((item) => item.id === fieldId);
+      const label = field?.label || fieldId;
+      return {
+        columnKey: fieldId,
+        columnLabel: label,
+        textValue: fieldValue
+      };
+    });
+  }
+};
+
 // src/logic/index.ts
 var logicRegistry = defineLogicRegistry({
+  textInput: textInputLogic,
+  numberInput: numberInputLogic,
+  emailInput: emailInputLogic,
+  dateInput: dateInputLogic,
+  multiInput: multiInputLogic,
+  zipCodeInput: zipCodeInputLogic,
+  singleChoice: singleChoiceLogic,
+  multipleChoice: multipleChoiceLogic,
+  dropdown: dropdownLogic,
+  ranking: rankingLogic,
+  rating: ratingLogic,
+  slider: sliderLogic,
   plainText: plainTextLogic
 });
 export {
   createInitialData,
+  dateInputLogic,
   defineLogicRegistry,
+  dropdownLogic,
+  emailInputLogic,
   logicRegistry,
-  plainTextLogic
+  multiInputLogic,
+  multipleChoiceLogic,
+  numberInputLogic,
+  plainTextLogic,
+  rankingLogic,
+  ratingLogic,
+  singleChoiceLogic,
+  sliderLogic,
+  textInputLogic,
+  zipCodeInputLogic
 };