@streamline-pulse/formkrafter-core 0.1.0

package/dist/index.js

@@ -0,0 +1,1006 @@
+// lib/utils/localized-text.ts
+function isLocalizedObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length > 0 && Object.values(value).every((entry) => typeof entry === "string");
+}
+function resolveLocalizedText(value, locale) {
+  if (!isLocalizedObject(value))
+    return value;
+  if (locale && value[locale] !== undefined)
+    return value[locale];
+  return Object.values(value)[0];
+}
+function resolveLocalizedRecord(record, locale) {
+  if (!record)
+    return record;
+  const resolved = {};
+  for (const [key, value] of Object.entries(record)) {
+    resolved[key] = resolveLocalizedText(value, locale);
+  }
+  return resolved;
+}
+
+// lib/validators/default-messages.ts
+var DEFAULT_MESSAGES = {
+  en: {
+    required: "This field is required",
+    minLength: "Must be at least {value} characters",
+    maxLength: "Must be at most {value} characters",
+    min: "Must be at least {value}",
+    max: "Must be at most {value}",
+    pattern: "Invalid format",
+    minItems: "Select at least {value} item(s)",
+    maxItems: "Select at most {value} item(s)",
+    email: "Invalid email address",
+    url: "Invalid URL",
+    type: "Invalid value",
+    custom: "Invalid value"
+  },
+  fr: {
+    required: "Ce champ est obligatoire",
+    minLength: "Minimum {value} caractères",
+    maxLength: "Maximum {value} caractères",
+    min: "Minimum {value}",
+    max: "Maximum {value}",
+    pattern: "Format invalide",
+    minItems: "Sélectionnez au moins {value} élément(s)",
+    maxItems: "Sélectionnez au plus {value} élément(s)",
+    email: "Adresse email invalide",
+    url: "URL invalide",
+    type: "Valeur invalide",
+    custom: "Valeur invalide"
+  }
+};
+function registerValidationMessages(locale, messages) {
+  DEFAULT_MESSAGES[locale] = { ...DEFAULT_MESSAGES[locale], ...messages };
+}
+function defaultValidationMessage(validator, locale, value) {
+  const pack = DEFAULT_MESSAGES[locale ?? "en"] ?? DEFAULT_MESSAGES.en;
+  const template = pack[validator] ?? DEFAULT_MESSAGES.en[validator] ?? "Invalid value";
+  return template.replace("{value}", String(value ?? ""));
+}
+
+// lib/utils/brick-spec.ts
+function* iterateBricks(spec, path = "0") {
+  if (!spec)
+    return;
+  yield { brick: spec, path };
+  for (const [index, child] of (spec.children ?? []).entries()) {
+    yield* iterateBricks(child, `${path}.${index}`);
+  }
+}
+function* iterateSchemaBricks(spec) {
+  if (!spec)
+    return;
+  yield spec;
+  if (spec.type === "collection")
+    return;
+  for (const child of spec.children ?? []) {
+    yield* iterateSchemaBricks(child);
+  }
+}
+function buildValidationSchema(brickSpecs, locale) {
+  if (!brickSpecs)
+    return;
+  const properties = {};
+  const required = [];
+  const requiredErrorMessage = {};
+  const messageOf = (raw) => {
+    const resolved = resolveLocalizedText(raw, locale);
+    return typeof resolved === "string" ? resolved : undefined;
+  };
+  for (const brick of iterateSchemaBricks(brickSpecs)) {
+    const key = brick.configs?.key;
+    const dataType = brick.dataType;
+    if (!key || !dataType || dataType === "void")
+      continue;
+    const isRequired = brick.validations?.find((validation2) => validation2.validator === "required");
+    const property = {
+      type: dataType,
+      nullable: !isRequired
+    };
+    const messages = {
+      type: defaultValidationMessage("type", locale)
+    };
+    for (const validation2 of brick.validations ?? []) {
+      const { validator, value } = validation2;
+      const message = messageOf(validation2.message) ?? defaultValidationMessage(validator, locale, value);
+      if (validator === "minLength" && value != null) {
+        property.minLength = Number(value);
+        messages.minLength = message;
+      } else if (validator === "maxLength" && value != null) {
+        property.maxLength = Number(value);
+        messages.maxLength = message;
+      } else if (validator === "min" && value != null) {
+        property.minimum = Number(value);
+        messages.minimum = message;
+      } else if (validator === "max" && value != null) {
+        property.maximum = Number(value);
+        messages.maximum = message;
+      } else if (validator === "pattern" && typeof value === "string" && value) {
+        property.pattern = value;
+        messages.pattern = message;
+      } else if (validator === "minItems" && value != null) {
+        property.minItems = Number(value);
+        messages.minItems = message;
+      } else if (validator === "maxItems" && value != null) {
+        property.maxItems = Number(value);
+        messages.maxItems = message;
+      } else if (validator === "email") {
+        property.format = "email";
+        messages.format = message;
+      } else if (validator === "url") {
+        property.format = "uri";
+        messages.format = message;
+      }
+    }
+    property.errorMessage = messages;
+    properties[key] = property;
+    if (isRequired) {
+      required.push(key);
+      requiredErrorMessage[key] = messageOf(isRequired.message) ?? defaultValidationMessage("required", locale);
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    required,
+    ...Object.keys(requiredErrorMessage).length ? {
+      errorMessage: {
+        required: requiredErrorMessage
+      }
+    } : {},
+    additionalProperties: false
+  };
+}
+// lib/brick/brick.ts
+class Brick {
+  type;
+  dataType;
+  id;
+  name;
+  configsForm;
+  category;
+  styles;
+  unWrapData;
+  isPrivate;
+  validators;
+  defaultConfigs;
+  constructor(params) {
+    this.type = params.type;
+    this.dataType = params.dataType;
+    this.id = params.id;
+    this.name = params.name;
+    this.configsForm = params.configsForm;
+    this.category = params.category;
+    this.styles = params.styles;
+    this.unWrapData = params.unWrapData ?? false;
+    this.isPrivate = params.isPrivate ?? false;
+    this.validators = params.validators ?? [];
+    this.defaultConfigs = params.defaultConfigs;
+  }
+  getBrickEmptySpec() {
+    return {
+      type: this.type,
+      dataType: this.dataType,
+      id: this.id,
+      name: this.name,
+      ...this.category !== undefined ? { category: this.category } : {},
+      ...this.configsForm !== undefined ? { configsForm: this.configsForm } : {},
+      ...this.styles !== undefined ? { styles: this.styles } : {},
+      ...this.defaultConfigs !== undefined ? { configs: { ...this.defaultConfigs } } : {},
+      validators: this.validators
+    };
+  }
+}
+// lib/brick/utils.ts
+import jsonLogic from "json-logic-js";
+
+// lib/services/js_runner_service.ts
+import { parse as parse2 } from "acorn";
+
+// lib/services/sandbox_interpreter.ts
+import { parse } from "acorn";
+var FORBIDDEN_PROPS = new Set(["__proto__", "constructor", "prototype"]);
+var MAX_STEPS = 1e5;
+
+class ReturnSignal {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+}
+var lookup = (ctx, name) => {
+  for (let i = ctx.scopes.length - 1;i >= 0; i--) {
+    if (ctx.scopes[i].has(name))
+      return ctx.scopes[i].get(name);
+  }
+  throw new Error(`Unknown identifier "${name}"`);
+};
+var declareVar = (ctx, name, value) => {
+  ctx.scopes[ctx.scopes.length - 1].set(name, value);
+};
+var assign = (ctx, name, value) => {
+  for (let i = ctx.scopes.length - 1;i >= 0; i--) {
+    if (ctx.scopes[i].has(name)) {
+      ctx.scopes[i].set(name, value);
+      return;
+    }
+  }
+  throw new Error(`Cannot assign to unknown identifier "${name}"`);
+};
+var guardProp = (prop) => {
+  if (typeof prop === "number")
+    return prop;
+  const name = String(prop);
+  if (FORBIDDEN_PROPS.has(name)) {
+    throw new Error(`Access to "${name}" is not allowed`);
+  }
+  return name;
+};
+var memberTarget = (ctx, node) => {
+  const object = evalNode(ctx, node.object);
+  const prop = node.computed ? guardProp(evalNode(ctx, node.property)) : guardProp(node.property.name);
+  return { object, prop, optional: node.optional === true };
+};
+var readMember = (ctx, node) => {
+  const { object, prop, optional } = memberTarget(ctx, node);
+  if (object === null || object === undefined) {
+    if (optional)
+      return;
+    throw new Error(`Cannot read "${String(prop)}" of ${String(object)}`);
+  }
+  return object[prop];
+};
+var evalNode = (ctx, node) => {
+  if (++ctx.steps > MAX_STEPS) {
+    throw new Error("Sandbox execution budget exceeded");
+  }
+  switch (node.type) {
+    case "Program":
+    case "BlockStatement": {
+      for (const statement of node.body) {
+        const result = evalNode(ctx, statement);
+        if (result instanceof ReturnSignal)
+          return result;
+      }
+      return;
+    }
+    case "ReturnStatement":
+      return new ReturnSignal(node.argument ? evalNode(ctx, node.argument) : undefined);
+    case "IfStatement": {
+      if (evalNode(ctx, node.test)) {
+        return evalNode(ctx, node.consequent);
+      }
+      if (node.alternate)
+        return evalNode(ctx, node.alternate);
+      return;
+    }
+    case "VariableDeclaration": {
+      for (const declaration of node.declarations) {
+        const id = declaration.id;
+        if (id.type !== "Identifier") {
+          throw new Error("Only simple variable names are supported");
+        }
+        declareVar(ctx, id.name, declaration.init ? evalNode(ctx, declaration.init) : undefined);
+      }
+      return;
+    }
+    case "ExpressionStatement":
+      evalNode(ctx, node.expression);
+      return;
+    case "Literal":
+      return node.value;
+    case "TemplateLiteral": {
+      const quasis = node.quasis;
+      const expressions = node.expressions;
+      let text = "";
+      quasis.forEach((quasi, index) => {
+        text += quasi.value.cooked ?? "";
+        if (index < expressions.length) {
+          text += String(evalNode(ctx, expressions[index]));
+        }
+      });
+      return text;
+    }
+    case "Identifier":
+      return lookup(ctx, node.name);
+    case "ThisExpression":
+      return;
+    case "ChainExpression":
+      return evalNode(ctx, node.expression);
+    case "MemberExpression":
+      return readMember(ctx, node);
+    case "CallExpression": {
+      const callee = node.callee;
+      const args = [];
+      for (const argument of node.arguments) {
+        if (argument.type === "SpreadElement") {
+          const spread = evalNode(ctx, argument.argument);
+          if (Array.isArray(spread))
+            args.push(...spread);
+        } else {
+          args.push(evalNode(ctx, argument));
+        }
+      }
+      if (callee.type === "MemberExpression") {
+        const { object, prop, optional } = memberTarget(ctx, callee);
+        if (object === null || object === undefined) {
+          if (optional || node.optional === true)
+            return;
+          throw new Error(`Cannot call "${String(prop)}" of ${String(object)}`);
+        }
+        const fn3 = object[prop];
+        if (typeof fn3 !== "function") {
+          if (node.optional === true && fn3 == null)
+            return;
+          throw new Error(`"${String(prop)}" is not a function`);
+        }
+        if (fn3 === Function || fn3 === eval) {
+          throw new Error("This function is not allowed");
+        }
+        return fn3.apply(object, args);
+      }
+      const fn2 = evalNode(ctx, callee);
+      if (typeof fn2 !== "function") {
+        if (node.optional === true && fn2 == null)
+          return;
+        throw new Error("Value is not a function");
+      }
+      if (fn2 === Function || fn2 === eval) {
+        throw new Error("This function is not allowed");
+      }
+      return fn2(...args);
+    }
+    case "ArrowFunctionExpression": {
+      const params = node.params;
+      const body = node.body;
+      const capturedScopes = [...ctx.scopes];
+      return (...args) => {
+        const callScope = new Map;
+        params.forEach((param, index) => {
+          if (param.type !== "Identifier") {
+            throw new Error("Only simple parameters are supported");
+          }
+          callScope.set(param.name, args[index]);
+        });
+        const callCtx = {
+          steps: ctx.steps,
+          scopes: [...capturedScopes, callScope]
+        };
+        const result = evalNode(callCtx, body);
+        ctx.steps = callCtx.steps;
+        if (result instanceof ReturnSignal)
+          return result.value;
+        return node.expression === true ? result : undefined;
+      };
+    }
+    case "BinaryExpression": {
+      const left = evalNode(ctx, node.left);
+      const right = evalNode(ctx, node.right);
+      switch (node.operator) {
+        case "===":
+          return left === right;
+        case "!==":
+          return left !== right;
+        case "==":
+          return left == right;
+        case "!=":
+          return left != right;
+        case "<":
+          return left < right;
+        case "<=":
+          return left <= right;
+        case ">":
+          return left > right;
+        case ">=":
+          return left >= right;
+        case "+":
+          return left + right;
+        case "-":
+          return left - right;
+        case "*":
+          return left * right;
+        case "/":
+          return left / right;
+        case "%":
+          return left % right;
+        case "**":
+          return left ** right;
+        default:
+          throw new Error(`Unsupported operator "${String(node.operator)}"`);
+      }
+    }
+    case "LogicalExpression": {
+      const left = evalNode(ctx, node.left);
+      switch (node.operator) {
+        case "&&":
+          return left && evalNode(ctx, node.right);
+        case "||":
+          return left || evalNode(ctx, node.right);
+        case "??":
+          return left ?? evalNode(ctx, node.right);
+        default:
+          throw new Error(`Unsupported operator "${String(node.operator)}"`);
+      }
+    }
+    case "UnaryExpression": {
+      const argument = evalNode(ctx, node.argument);
+      switch (node.operator) {
+        case "!":
+          return !argument;
+        case "-":
+          return -argument;
+        case "+":
+          return +argument;
+        case "typeof":
+          return typeof argument;
+        default:
+          throw new Error(`Unsupported operator "${String(node.operator)}"`);
+      }
+    }
+    case "ConditionalExpression":
+      return evalNode(ctx, node.test) ? evalNode(ctx, node.consequent) : evalNode(ctx, node.alternate);
+    case "AssignmentExpression": {
+      const target = node.left;
+      if (target.type !== "Identifier" || node.operator !== "=") {
+        throw new Error("Only simple assignments are supported");
+      }
+      const value = evalNode(ctx, node.right);
+      assign(ctx, target.name, value);
+      return value;
+    }
+    case "ArrayExpression": {
+      const values = [];
+      for (const element of node.elements) {
+        if (!element)
+          continue;
+        if (element.type === "SpreadElement") {
+          const spread = evalNode(ctx, element.argument);
+          if (Array.isArray(spread))
+            values.push(...spread);
+        } else {
+          values.push(evalNode(ctx, element));
+        }
+      }
+      return values;
+    }
+    case "ObjectExpression": {
+      const result = {};
+      for (const property of node.properties) {
+        if (property.type === "SpreadElement") {
+          const spread = evalNode(ctx, property.argument);
+          if (spread && typeof spread === "object") {
+            for (const [key2, value] of Object.entries(spread)) {
+              result[String(guardProp(key2))] = value;
+            }
+          }
+          continue;
+        }
+        const keyNode = property.key;
+        const key = property.computed ? guardProp(evalNode(ctx, keyNode)) : guardProp(keyNode.type === "Identifier" ? keyNode.name : keyNode.value);
+        result[String(key)] = evalNode(ctx, property.value);
+      }
+      return result;
+    }
+    default:
+      throw new Error(`Unsupported syntax: ${node.type}`);
+  }
+};
+var SAFE_BUILTINS = {
+  undefined: undefined,
+  NaN: NaN,
+  Infinity: Infinity,
+  Math,
+  JSON,
+  Number,
+  String,
+  Boolean,
+  Array,
+  Object,
+  Date,
+  parseInt,
+  parseFloat,
+  isNaN,
+  isFinite
+};
+function runSandboxed(code, globals = {}) {
+  const ast = parse(code, {
+    ecmaVersion: "latest",
+    allowReturnOutsideFunction: true
+  });
+  const ctx = {
+    steps: 0,
+    scopes: [
+      new Map(Object.entries({ ...SAFE_BUILTINS, ...globals })),
+      new Map
+    ]
+  };
+  const result = evalNode(ctx, ast);
+  return result instanceof ReturnSignal ? result.value : undefined;
+}
+
+// lib/services/js_runner_service.ts
+class SandboxJsRunnerService {
+  validateJs(js2, options = { ecmaVersion: "latest", allowReturnOutsideFunction: true }) {
+    try {
+      parse2(js2, options);
+      return { valide: true };
+    } catch (error) {
+      return {
+        valide: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  }
+  eval(js2, scope2 = {}) {
+    return runSandboxed(js2, scope2);
+  }
+}
+var JsRunnerServiceImplementation = SandboxJsRunnerService;
+
+// lib/services/data_source_service.ts
+class FetchDataSourceService {
+  defaults;
+  cache = new Map;
+  constructor(defaults = {}) {
+    this.defaults = defaults;
+  }
+  fetchOptions(url, options) {
+    const headers = { ...this.defaults.headers, ...options?.headers };
+    const init = {};
+    if (Object.keys(headers).length)
+      init.headers = headers;
+    if (this.defaults.credentials)
+      init.credentials = this.defaults.credentials;
+    const key = `${url}|${JSON.stringify(init)}`;
+    let pending = this.cache.get(key);
+    if (!pending) {
+      pending = fetch(url, Object.keys(init).length ? init : undefined).then((response) => {
+        if (!response.ok) {
+          throw new Error(`Data source request failed (${response.status}): ${url}`);
+        }
+        return response.json();
+      }).then((json) => Array.isArray(json) ? json : []).catch((error) => {
+        this.cache.delete(key);
+        throw error;
+      });
+      this.cache.set(key, pending);
+    }
+    return pending;
+  }
+}
+
+// lib/services/file_upload_service.ts
+class Base64FileUploadService {
+  async upload(file) {
+    const encode = globalThis.btoa;
+    if (!encode)
+      throw new Error("No base64 encoder available");
+    const bytes = new Uint8Array(await file.arrayBuffer());
+    let binary = "";
+    for (const byte of bytes)
+      binary += String.fromCharCode(byte);
+    return {
+      name: file.name,
+      type: file.type,
+      size: file.size,
+      url: `data:${file.type};base64,${encode(binary)}`
+    };
+  }
+}
+
+// lib/services/index.ts
+var GLOBAL_KEY = Symbol.for("formkrafter.core.services");
+var globalStore = globalThis;
+var services = globalStore[GLOBAL_KEY] ??= {
+  jsRunnerService: new SandboxJsRunnerService,
+  dataSourceService: new FetchDataSourceService,
+  fileUploadService: new Base64FileUploadService
+};
+
+// lib/brick/utils.ts
+var evalBrickCode = (code, data) => {
+  try {
+    return services.jsRunnerService.eval(code, { dataMap: data ?? {} });
+  } catch (error) {
+    return error instanceof Error ? error : new Error(String(error));
+  }
+};
+var evalRule = (rule, dataMap) => {
+  if (rule.type === "jsonLogic") {
+    if (rule.logic == null)
+      return false;
+    return jsonLogic.apply(rule.logic, dataMap) === true;
+  }
+  if (rule.type === "javaScript") {
+    if (!rule.code)
+      return false;
+    return evalBrickCode(rule.code, dataMap) === true;
+  }
+  return false;
+};
+var getActiveRules = (rules, dataMap) => rules?.filter((rule) => evalRule(rule, dataMap));
+var getActiveEffect = (rules, dataMap) => getActiveRules(rules, dataMap)?.map((rule) => rule.effects).flat().filter((effect) => effect != null);
+var getAffectedProperties = (rules, dataMap) => {
+  return getActiveEffect(rules, dataMap)?.map((effect) => {
+    let value;
+    if (effect.property) {
+      if (effect.property.type === "boolean")
+        value = effect.boolean;
+      else if (effect.property.type === "logic" && effect.logic != null)
+        value = jsonLogic.apply(effect.logic, dataMap);
+      else if (effect.property.type === "code" && effect.code)
+        value = evalBrickCode(effect.code, dataMap);
+      else if (effect.property.type === "string")
+        value = effect.string;
+      return {
+        [effect.property.target]: value
+      };
+    }
+    return {};
+  }).flat().reduce((acc, item) => ({ ...acc, ...item }), {}) ?? { hidden: false };
+};
+// lib/validators/validator.ts
+import { Ajv } from "ajv";
+import ajvErrors from "ajv-errors";
+import addFormats from "ajv-formats";
+var ajv = new Ajv({ allErrors: true });
+addFormats(ajv, ["email", "uri"]);
+ajvErrors(ajv);
+var validatorCache = new WeakMap;
+var compiledValidator = (brickSpec, locale) => {
+  let byLocale = validatorCache.get(brickSpec);
+  if (!byLocale) {
+    byLocale = new Map;
+    validatorCache.set(brickSpec, byLocale);
+  }
+  const cacheKey = locale ?? "";
+  let validate = byLocale.get(cacheKey);
+  if (!validate) {
+    const schema = buildValidationSchema(brickSpec, locale);
+    if (!schema)
+      return;
+    try {
+      validate = ajv.compile(schema);
+    } catch {
+      return;
+    }
+    byLocale.set(cacheKey, validate);
+  }
+  return validate;
+};
+var customErrors = (brickSpec, data, locale) => {
+  const errors = {};
+  const dataMap = data ?? {};
+  for (const brick of iterateSchemaBricks(brickSpec)) {
+    const key = brick.configs?.key;
+    if (!key)
+      continue;
+    for (const validation2 of brick.validations ?? []) {
+      if (validation2.validator !== "custom" || !validation2.customValidator) {
+        continue;
+      }
+      const result = evalBrickCode(`const value = dataMap?.[${JSON.stringify(key)}];
+${validation2.customValidator}`, dataMap);
+      if (result === true || result === undefined || result === null)
+        continue;
+      if (key in errors)
+        continue;
+      if (typeof result === "string")
+        errors[key] = result;
+      else if (result instanceof Error)
+        errors[key] = result.message;
+      else {
+        const resolved = resolveLocalizedText(validation2.message, locale);
+        errors[key] = typeof resolved === "string" ? resolved : defaultValidationMessage("custom", locale);
+      }
+    }
+  }
+  return errors;
+};
+var keyOfError = (error) => {
+  if (error.keyword === "required") {
+    return error.params.missingProperty;
+  }
+  if (error.keyword === "errorMessage") {
+    const inner = error.params.errors?.[0];
+    return inner ? keyOfError(inner) : undefined;
+  }
+  return error.instancePath.split("/").filter(Boolean)[0];
+};
+var validateBrickSpecDataDetailed = (brickSpec, data, locale) => {
+  const errors = {};
+  const validate = compiledValidator(brickSpec, locale);
+  if (validate && !validate(data)) {
+    for (const error of validate.errors ?? []) {
+      const key = keyOfError(error);
+      if (key && !(key in errors) && error.message) {
+        errors[key] = error.message;
+      }
+    }
+  }
+  for (const [key, message] of Object.entries(customErrors(brickSpec, data, locale))) {
+    if (!(key in errors))
+      errors[key] = message;
+  }
+  return { valid: Object.keys(errors).length === 0, errors };
+};
+var validateBrickSpecData = (brickSpec, data, locale) => validateBrickSpecDataDetailed(brickSpec, data, locale).valid;
+var stripEmpty = (data) => {
+  if (typeof data !== "object" || data === null)
+    return {};
+  return Object.fromEntries(Object.entries(data).filter(([, value]) => value !== "" && value !== null && value !== undefined));
+};
+var rowSpecCache = new WeakMap;
+var rowSpecOf = (collection) => {
+  let rowSpec = rowSpecCache.get(collection);
+  if (!rowSpec) {
+    rowSpec = {
+      type: "panel",
+      id: "collection-row",
+      name: "Row",
+      configs: { key: `${collection.configs?.key ?? "collection"}_row` },
+      children: collection.children ?? []
+    };
+    rowSpecCache.set(collection, rowSpec);
+  }
+  return rowSpec;
+};
+var validateFormData = (brickSpec, data, locale) => {
+  const present = stripEmpty(data);
+  const errors = {
+    ...validateBrickSpecDataDetailed(brickSpec, present, locale).errors
+  };
+  for (const brick of iterateSchemaBricks(brickSpec)) {
+    if (brick.type !== "collection")
+      continue;
+    const key = brick.configs?.key;
+    if (!key)
+      continue;
+    const rows = present[key];
+    if (!Array.isArray(rows))
+      continue;
+    const rowSpec = rowSpecOf(brick);
+    rows.forEach((row, index) => {
+      const rowResult = validateFormData(rowSpec, row, locale);
+      for (const [field, message] of Object.entries(rowResult.errors)) {
+        const prefixed = `${key}[${index}].${field}`;
+        if (!(prefixed in errors))
+          errors[prefixed] = message;
+      }
+    });
+  }
+  return { valid: Object.keys(errors).length === 0, errors };
+};
+// lib/services/unsafe_js_runner_service.ts
+import { parse as parse3 } from "acorn";
+
+class UnsafeEvalJsRunnerService {
+  validateJs(js2, options = { ecmaVersion: "latest", allowReturnOutsideFunction: true }) {
+    try {
+      parse3(js2, options);
+      return { valide: true };
+    } catch (error) {
+      return {
+        valide: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  }
+  eval(js, scope = {}) {
+    const prelude = Object.entries(scope).map(([name, value]) => `const ${name} = ${JSON.stringify(value)};`).join(`
+`);
+    const fn = `(() => {${prelude}
+${js}})();`;
+    const validation = this.validateJs(fn, { ecmaVersion: "latest" });
+    if (!validation.valide)
+      throw validation.error;
+    return eval(fn);
+  }
+}
+// lib/ops/pointer.ts
+function pointerFromPath(path) {
+  return path.split(".").slice(1).map((segment) => `/children/${segment}`).join("");
+}
+function pointerOfUid(spec, uid) {
+  if (spec.configs?.uid === uid)
+    return "";
+  for (const [index, child] of (spec.children ?? []).entries()) {
+    const childPointer = pointerOfUid(child, uid);
+    if (childPointer !== undefined)
+      return `/children/${index}${childPointer}`;
+  }
+  return;
+}
+function getBrickAt(spec, path) {
+  let current = spec;
+  for (const segment of path.split(".").slice(1)) {
+    current = current?.children?.[Number(segment)];
+  }
+  return current;
+}
+// lib/utils/fast-json-patch.ts
+import * as fastJsonPatchModule from "fast-json-patch";
+var fastJsonPatch = fastJsonPatchModule.default ?? fastJsonPatchModule;
+var applyPatch = fastJsonPatch.applyPatch;
+
+// lib/ops/ops.ts
+var apply = (spec, patches, inverse) => ({
+  spec: applyPatch(spec, patches, true, false).newDocument,
+  patches,
+  inverse
+});
+var requireBrickAt = (spec, path) => {
+  const brick = getBrickAt(spec, path);
+  if (!brick)
+    throw new Error(`No brick at path "${path}"`);
+  return brick;
+};
+var requireBrickByUid = (spec, uid) => {
+  const pointer = pointerOfUid(spec, uid);
+  if (pointer === undefined)
+    throw new Error(`No brick with uid "${uid}"`);
+  let brick = spec;
+  for (const segment of pointer.split("/children/").slice(1)) {
+    brick = brick.children[Number(segment)];
+  }
+  return { pointer, brick };
+};
+var toJsonValue = (value) => JSON.parse(JSON.stringify(value));
+function addBrick(spec, brick, parentPath, index) {
+  const parent = requireBrickAt(spec, parentPath);
+  const parentPointer = pointerFromPath(parentPath);
+  const value = toJsonValue(brick);
+  if (!parent.children) {
+    const pointer2 = `${parentPointer}/children`;
+    return apply(spec, [{ op: "add", path: pointer2, value: [value] }], [{ op: "remove", path: pointer2 }]);
+  }
+  const position = Math.min(index ?? parent.children.length, parent.children.length);
+  const pointer = `${parentPointer}/children/${position}`;
+  return apply(spec, [{ op: "add", path: pointer, value }], [{ op: "remove", path: pointer }]);
+}
+function removeBrick(spec, path) {
+  if (path === "0")
+    throw new Error("Cannot remove the root brick");
+  const brick = requireBrickAt(spec, path);
+  const pointer = pointerFromPath(path);
+  return apply(spec, [{ op: "remove", path: pointer }], [{ op: "add", path: pointer, value: brick }]);
+}
+function moveBrick(spec, from, to) {
+  if (from === "0" || to === "0")
+    throw new Error("Cannot move the root brick");
+  const brick = requireBrickAt(spec, from);
+  const fromSegments = from.split(".").map(Number);
+  const toSegments = to.split(".").map(Number);
+  const parentLength = fromSegments.length - 1;
+  const fromIndex = fromSegments[parentLength];
+  const sharesFromParent = toSegments.length > parentLength && fromSegments.slice(0, parentLength).every((segment, i) => segment === toSegments[i]);
+  const adjusted = [...toSegments];
+  if (sharesFromParent) {
+    if (adjusted[parentLength] === fromIndex && adjusted.length > fromSegments.length) {
+      throw new Error(`Cannot move a brick into its own subtree ("${from}" → "${to}")`);
+    }
+    if (adjusted[parentLength] > fromIndex)
+      adjusted[parentLength] -= 1;
+  }
+  const fromPointer = pointerFromPath(from);
+  const toPointer = pointerFromPath(adjusted.join("."));
+  return apply(spec, [
+    { op: "remove", path: fromPointer },
+    { op: "add", path: toPointer, value: brick }
+  ], [
+    { op: "remove", path: toPointer },
+    { op: "add", path: fromPointer, value: brick }
+  ]);
+}
+var withFreshUids = (brick) => ({
+  ...brick,
+  ...brick.configs ? { configs: { ...brick.configs, uid: crypto.randomUUID() } } : {},
+  ...brick.children ? { children: brick.children.map(withFreshUids) } : {}
+});
+function duplicateBrick(spec, path) {
+  if (path === "0")
+    throw new Error("Cannot duplicate the root brick");
+  const brick = requireBrickAt(spec, path);
+  const segments = path.split(".");
+  const nextIndex = Number(segments[segments.length - 1]) + 1;
+  const pointer = pointerFromPath([...segments.slice(0, -1), String(nextIndex)].join("."));
+  const copy = withFreshUids(toJsonValue(brick));
+  return apply(spec, [{ op: "add", path: pointer, value: copy }], [{ op: "remove", path: pointer }]);
+}
+var setBrickSection = (spec, brickPointer, section, value, previous) => {
+  const pointer = `${brickPointer}/${section}`;
+  if (previous === undefined) {
+    return apply(spec, [{ op: "add", path: pointer, value }], [{ op: "remove", path: pointer }]);
+  }
+  return apply(spec, [{ op: "replace", path: pointer, value }], [{ op: "replace", path: pointer, value: previous }]);
+};
+function updateBrickConfigs(spec, uid, configs) {
+  const { pointer, brick } = requireBrickByUid(spec, uid);
+  const merged = { ...brick.configs, ...configs };
+  return setBrickSection(spec, pointer, "configs", merged, brick.configs);
+}
+function updateBrickStyles(spec, uid, styles) {
+  const { pointer, brick } = requireBrickByUid(spec, uid);
+  const merged = { ...brick.styles, ...styles };
+  return setBrickSection(spec, pointer, "styles", merged, brick.styles);
+}
+function updateBrickValidations(spec, uid, validations) {
+  const { pointer, brick } = requireBrickByUid(spec, uid);
+  return setBrickSection(spec, pointer, "validations", validations, brick.validations);
+}
+function updateBrickRules(spec, uid, rules) {
+  const { pointer, brick } = requireBrickByUid(spec, uid);
+  return setBrickSection(spec, pointer, "rules", rules, brick.rules);
+}
+// lib/ops/history.ts
+class SpecHistory {
+  past = [];
+  future = [];
+  record(update) {
+    this.past.push({ patches: update.patches, inverse: update.inverse });
+    this.future = [];
+  }
+  get canUndo() {
+    return this.past.length > 0;
+  }
+  get canRedo() {
+    return this.future.length > 0;
+  }
+  undo(spec) {
+    const entry = this.past.pop();
+    if (!entry)
+      return;
+    this.future.push(entry);
+    return applyPatch(spec, entry.inverse, true, false).newDocument;
+  }
+  redo(spec) {
+    const entry = this.future.pop();
+    if (!entry)
+      return;
+    this.past.push(entry);
+    return applyPatch(spec, entry.patches, true, false).newDocument;
+  }
+  clear() {
+    this.past = [];
+    this.future = [];
+  }
+}
+export {
+  validateFormData,
+  validateBrickSpecDataDetailed,
+  validateBrickSpecData,
+  updateBrickValidations,
+  updateBrickStyles,
+  updateBrickRules,
+  updateBrickConfigs,
+  services,
+  runSandboxed,
+  resolveLocalizedText,
+  resolveLocalizedRecord,
+  removeBrick,
+  registerValidationMessages,
+  pointerOfUid,
+  pointerFromPath,
+  moveBrick,
+  iterateSchemaBricks,
+  iterateBricks,
+  isLocalizedObject,
+  getBrickAt,
+  getAffectedProperties,
+  evalBrickCode,
+  duplicateBrick,
+  defaultValidationMessage,
+  buildValidationSchema,
+  addBrick,
+  UnsafeEvalJsRunnerService,
+  SpecHistory,
+  SandboxJsRunnerService,
+  JsRunnerServiceImplementation,
+  FetchDataSourceService,
+  Brick,
+  Base64FileUploadService
+};
+
+//# debugId=C472894AC5683A1F64756E2164756E21
+//# sourceMappingURL=index.js.map