@pixerate/editor 0.23.0 → 0.24.0

package/dist/chunk-OXSV64JX.js

@@ -0,0 +1,689 @@
+import {
+  getPromptDiagnostics,
+  getTemplateBody,
+  resolvePrompt,
+  tokenizePrompt
+} from "./chunk-FPENXAEJ.js";
+import {
+  INSTRUCTION_REGEX,
+  TEMPLATE_REGEX,
+  VARIABLE_REGEX,
+  conditionSubject,
+  evaluateConditionExpression,
+  parseConditionExpression,
+  parseVariableBody
+} from "./chunk-P6ODPZ4W.js";
+import {
+  parseCsv
+} from "./chunk-664LQYFJ.js";
+
+// src/grammar/resolver.ts
+function resolveTemplates(text, templates = [], options) {
+  return resolvePrompt(text, templates, options).text;
+}
+function resolveVariables(text, values) {
+  if (!text) return "";
+  return resolvePrompt(text, [], { values }).text;
+}
+function extractTemplateNames(text) {
+  if (!text) return [];
+  const set = /* @__PURE__ */ new Set();
+  const regex = new RegExp(TEMPLATE_REGEX.source, TEMPLATE_REGEX.flags);
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    set.add(match[1].trim());
+  }
+  return Array.from(set);
+}
+function extractVariableNames(text) {
+  if (!text) return [];
+  const set = /* @__PURE__ */ new Set();
+  const regex = new RegExp(VARIABLE_REGEX.source, VARIABLE_REGEX.flags);
+  let comparisonStarts;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    const parsed = parseVariableBody(match[1]);
+    let name = parsed.name;
+    if (parsed.kind === "conditional" && parsed.conditional !== "end") {
+      const subject = conditionSubject(name);
+      if (subject) {
+        comparisonStarts ??= new Set(
+          tokenizePrompt(text).filter((token) => token.comparison).map((token) => token.start)
+        );
+        if (comparisonStarts.has(match.index)) name = subject;
+      }
+    }
+    set.add(name);
+  }
+  return Array.from(set);
+}
+function extractInstructionNames(text) {
+  if (!text) return [];
+  const set = /* @__PURE__ */ new Set();
+  const regex = new RegExp(INSTRUCTION_REGEX.source, INSTRUCTION_REGEX.flags);
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    set.add(match[1].trim());
+  }
+  return Array.from(set);
+}
+
+// src/grammar/sourcemap.ts
+function resolveTemplatesWithMapping(text, templates = [], templateBindings, options) {
+  if (options?.values === void 0 && (!templates || templates.length === 0 || !text.includes("{{"))) {
+    return {
+      diagnostics: getPromptDiagnostics(text),
+      text,
+      map: [
+        {
+          resolvedStart: 0,
+          resolvedEnd: text.length,
+          source: "raw",
+          rawStart: 0,
+          rawEnd: text.length
+        }
+      ]
+    };
+  }
+  return resolvePrompt(text, templates, {
+    bindings: templateBindings,
+    maxDepth: options?.maxDepth,
+    values: options?.values
+  });
+}
+function mapResolvedOffsetToRaw(resolvedOffset, map) {
+  for (let i = 0; i < map.length; i++) {
+    const seg = map[i];
+    const isLast = i === map.length - 1;
+    const inRange = isLast ? resolvedOffset >= seg.resolvedStart && resolvedOffset <= seg.resolvedEnd : resolvedOffset >= seg.resolvedStart && resolvedOffset < seg.resolvedEnd;
+    if (inRange) {
+      if (seg.source === "raw") {
+        return seg.rawStart + (resolvedOffset - seg.resolvedStart);
+      }
+      if (resolvedOffset === seg.resolvedEnd) {
+        return seg.rawEnd;
+      }
+      return seg.rawStart;
+    }
+  }
+  return resolvedOffset;
+}
+function mapRawOffsetToResolved(rawOffset, map) {
+  for (let i = 0; i < map.length; i++) {
+    const seg = map[i];
+    const isLast = i === map.length - 1;
+    const inRange = isLast ? rawOffset >= seg.rawStart && rawOffset <= seg.rawEnd : rawOffset >= seg.rawStart && rawOffset < seg.rawEnd;
+    if (inRange) {
+      if (seg.source === "raw") {
+        return seg.resolvedStart + (rawOffset - seg.rawStart);
+      }
+      if (rawOffset === seg.rawEnd) {
+        return seg.resolvedEnd;
+      }
+      return seg.resolvedStart;
+    }
+  }
+  return rawOffset;
+}
+
+// src/grammar/fields.ts
+function extractVariables(text, options = {}) {
+  const descriptors = /* @__PURE__ */ new Map();
+  const templateMap = new Map(
+    (options.templates ?? []).map((t) => [t.name, t])
+  );
+  const maxDepth = options.maxDepth ?? 10;
+  const describe = (name, templateName) => {
+    let descriptor = descriptors.get(name);
+    if (!descriptor) {
+      descriptor = {
+        name,
+        usedAsValue: false,
+        usedInCondition: false,
+        occurrences: 0,
+        templates: []
+      };
+      descriptors.set(name, descriptor);
+    }
+    descriptor.occurrences++;
+    if (templateName && !descriptor.templates.includes(templateName)) {
+      descriptor.templates.push(templateName);
+    }
+    return descriptor;
+  };
+  const visit = (source, visited, depth, templateName) => {
+    for (const token of tokenizePrompt(source)) {
+      if (token.type === "variable") {
+        const descriptor = describe(token.value, templateName);
+        descriptor.usedAsValue = true;
+        if (descriptor.defaultValue === void 0 && token.defaultValue !== void 0) {
+          descriptor.defaultValue = token.defaultValue;
+        }
+        if (descriptor.description === void 0 && token.description !== void 0) {
+          descriptor.description = token.description;
+        }
+      } else if (token.type === "conditional" && token.conditional !== "end") {
+        const descriptor = describe(token.value, templateName);
+        descriptor.usedInCondition = true;
+        if (token.comparison) descriptor.usedInComparison = true;
+      } else if (token.type === "template") {
+        const template = templateMap.get(token.value);
+        if (!template || visited.has(token.value) || depth + 1 > maxDepth) {
+          continue;
+        }
+        const body = getTemplateBody(template, options.bindings);
+        if (body === void 0) continue;
+        visit(body, new Set(visited).add(token.value), depth + 1, token.value);
+      }
+    }
+  };
+  if (text) visit(text, /* @__PURE__ */ new Set(), 0);
+  return Array.from(descriptors.values());
+}
+function getVariableFormFields(text, options = {}) {
+  return extractVariables(text, options).map((variable) => ({
+    name: variable.name,
+    label: variable.description || variable.name,
+    placeholder: variable.defaultValue ?? "",
+    ...variable.defaultValue !== void 0 ? { defaultValue: variable.defaultValue } : {},
+    ...variable.description !== void 0 ? { description: variable.description } : {},
+    required: variable.usedAsValue && variable.defaultValue === void 0,
+    conditionOnly: !variable.usedAsValue && !variable.usedInComparison
+  }));
+}
+function compactVariableValues(input) {
+  const values = {};
+  for (const [name, value] of Object.entries(input)) {
+    if (value !== null && value !== void 0 && value.trim() !== "") {
+      values[name] = value;
+    }
+  }
+  return values;
+}
+
+// src/grammar/data-source.ts
+var MAX_DATA_SOURCE_RECORDS = 1e5;
+var MAX_DATA_SOURCE_FIELDS = 1e3;
+var AUTO_DELIMITERS = [",", ";", "	"];
+function detectDelimiter(text) {
+  const counts = new Map(AUTO_DELIMITERS.map((d) => [d, 0]));
+  let quoted = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === '"') {
+      quoted = !quoted;
+      continue;
+    }
+    if (quoted) continue;
+    if (ch === "\n" || ch === "\r") break;
+    if (counts.has(ch)) counts.set(ch, counts.get(ch) + 1);
+  }
+  let best = ",";
+  for (const d of AUTO_DELIMITERS) {
+    if (counts.get(d) > counts.get(best)) best = d;
+  }
+  return best;
+}
+function normalizeFieldNames(row) {
+  const out = [];
+  const taken = /* @__PURE__ */ new Set();
+  row.forEach((cell, i) => {
+    const trimmed = cellText(cell).trim();
+    const base = trimmed === "" ? `Column ${i + 1}` : trimmed;
+    let name = base;
+    for (let k = 2; taken.has(name.toLowerCase()); k++) name = `${base} ${k}`;
+    taken.add(name.toLowerCase());
+    out.push(name);
+  });
+  return out;
+}
+function cellText(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "object") {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+  return String(value);
+}
+function setField(record, name, value) {
+  Object.defineProperty(record, name, {
+    value,
+    enumerable: true,
+    writable: true,
+    configurable: true
+  });
+}
+function isBlankRow(row) {
+  return row.every((cell) => cellText(cell).trim() === "");
+}
+function parseDataSource(input, options = {}) {
+  const warnings = [];
+  if (typeof input === "string") {
+    const format = options.format ?? "auto";
+    const trimmed = input.trim();
+    if (format === "json" || format === "auto" && /^\[/.test(trimmed)) {
+      let parsed;
+      let ok = true;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch (error) {
+        ok = false;
+        if (format === "json") {
+          warnings.push({
+            code: "invalid-json",
+            message: `Invalid JSON: ${error.message}`
+          });
+          return { fields: [], records: [], warnings, format: "json" };
+        }
+      }
+      if (ok) {
+        if (!Array.isArray(parsed)) {
+          warnings.push({
+            code: "unsupported-json",
+            message: "JSON data must be an array of objects or of arrays"
+          });
+          return { fields: [], records: [], warnings, format: "json" };
+        }
+        const result2 = fromArray(parsed, options, warnings);
+        return { ...result2, format: "json" };
+      }
+    }
+    const delimiter = !options.delimiter || options.delimiter === "auto" ? detectDelimiter(input) : options.delimiter;
+    let rows;
+    try {
+      rows = parseCsv(input, { delimiter });
+    } catch (error) {
+      warnings.push({ code: "empty", message: error.message });
+      return { fields: [], records: [], warnings, format: "csv", delimiter };
+    }
+    return {
+      ...fromRows(rows, options, warnings),
+      format: "csv",
+      delimiter
+    };
+  }
+  const result = fromArray(input, options, warnings);
+  return {
+    ...result,
+    format: result.objects ? "objects" : "rows"
+  };
+}
+function fromArray(items, options, warnings) {
+  const objects = items.some(
+    (item) => item !== null && typeof item === "object" && !Array.isArray(item)
+  );
+  if (!objects) {
+    const rows2 = items.filter((item) => Array.isArray(item));
+    return { ...fromRows(rows2, options, warnings), objects: false };
+  }
+  const maxFields = options.maxFields ?? MAX_DATA_SOURCE_FIELDS;
+  const maxRecords = options.maxRecords ?? MAX_DATA_SOURCE_RECORDS;
+  const fields = [];
+  const seen = /* @__PURE__ */ new Set();
+  let fieldsTruncated = false;
+  const rows = items.filter(
+    (item) => item !== null && typeof item === "object" && !Array.isArray(item)
+  );
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      if (seen.has(key)) continue;
+      if (fields.length >= maxFields) {
+        fieldsTruncated = true;
+        continue;
+      }
+      seen.add(key);
+      fields.push(key);
+    }
+  }
+  if (fieldsTruncated) {
+    warnings.push({
+      code: "fields-truncated",
+      message: `Only the first ${maxFields} fields were kept`
+    });
+  }
+  const records = [];
+  for (const row of rows) {
+    if (fields.every((field) => cellText(row[field]).trim() === "")) continue;
+    if (records.length >= maxRecords) {
+      warnings.push({
+        code: "records-truncated",
+        message: `Only the first ${maxRecords} records were kept`
+      });
+      break;
+    }
+    const record = {};
+    for (const field of fields) {
+      const value = Object.prototype.hasOwnProperty.call(row, field) ? row[field] : void 0;
+      setField(record, field, cellText(value));
+    }
+    records.push(record);
+  }
+  if (records.length === 0) {
+    warnings.push({ code: "empty", message: "The data source has no records" });
+  }
+  return { fields, records, warnings, objects: true };
+}
+function fromRows(allRows, options, warnings) {
+  const maxFields = options.maxFields ?? MAX_DATA_SOURCE_FIELDS;
+  const maxRecords = options.maxRecords ?? MAX_DATA_SOURCE_RECORDS;
+  const rows = allRows.filter((row) => !isBlankRow(row));
+  if (rows.length === 0) {
+    warnings.push({ code: "empty", message: "The data source has no records" });
+    return { fields: [], records: [], warnings };
+  }
+  const hasHeader = options.hasHeader ?? true;
+  let fields;
+  let body;
+  let widest;
+  if (hasHeader) {
+    const header = rows[0];
+    widest = header.length;
+    if (header.some((cell) => cellText(cell).trim() === "")) {
+      warnings.push({
+        code: "blank-header",
+        message: 'Blank column headers were named "Column N"'
+      });
+    }
+    fields = normalizeFieldNames(header.slice(0, maxFields));
+    const lower = header.map((cell) => cellText(cell).trim().toLowerCase());
+    if (lower.some((name, i) => name !== "" && lower.indexOf(name) !== i)) {
+      warnings.push({
+        code: "duplicate-header",
+        message: "Repeated column headers were numbered"
+      });
+    }
+    body = rows.slice(1);
+  } else {
+    widest = Math.max(...rows.map((row) => row.length));
+    fields = Array.from(
+      { length: Math.min(widest, maxFields) },
+      (_, i) => `Column ${i + 1}`
+    );
+    body = rows;
+  }
+  if (widest > maxFields) {
+    warnings.push({
+      code: "fields-truncated",
+      message: `Only the first ${maxFields} fields were kept`
+    });
+  }
+  if (body.length > maxRecords) {
+    warnings.push({
+      code: "records-truncated",
+      message: `Only the first ${maxRecords} of ${body.length} records were kept`
+    });
+    body = body.slice(0, maxRecords);
+  }
+  let ragged = 0;
+  const records = body.map((row) => {
+    if (hasHeader && row.length !== widest) ragged++;
+    const record = {};
+    fields.forEach((field, i) => setField(record, field, cellText(row[i])));
+    return record;
+  });
+  if (ragged > 0) {
+    warnings.push({
+      code: "ragged-rows",
+      message: `${ragged} record${ragged === 1 ? " was" : "s were"} padded or cut to ${widest} fields`,
+      count: ragged
+    });
+  }
+  if (records.length === 0) {
+    warnings.push({ code: "empty", message: "The data source has no records" });
+  }
+  return { fields, records, warnings };
+}
+function normalizeFieldKey(name) {
+  return name.toLowerCase().replace(/[\s_.\-]+/g, "");
+}
+var FIELD_ALIASES = [
+  ["FirstName", "First", "GivenName", "Forename", "FName"],
+  ["LastName", "Last", "Surname", "FamilyName", "LName"],
+  ["Name", "FullName", "DisplayName"],
+  ["Company", "CompanyName", "Organization", "Organisation", "Employer", "Business"],
+  ["Address", "AddressLine1", "Address1", "Street", "StreetAddress"],
+  ["City", "Town"],
+  ["State", "Province", "Region", "County"],
+  ["PostalCode", "ZIP", "ZipCode", "Postcode"],
+  ["Country", "CountryName", "Nation"],
+  ["Title", "CourtesyTitle", "Salutation", "Honorific"],
+  ["Email", "EmailAddress", "Mail", "EMail"],
+  ["Phone", "PhoneNumber", "Telephone", "Tel", "Mobile"]
+];
+function matchFields(variables, fields, options = {}) {
+  const names = Array.from(
+    new Set(variables.map((v) => typeof v === "string" ? v : v.name))
+  );
+  const byKey = /* @__PURE__ */ new Map();
+  for (const field of fields) {
+    const key = normalizeFieldKey(field);
+    if (!byKey.has(key)) byKey.set(key, field);
+  }
+  const groups = [...FIELD_ALIASES, ...options.aliases ?? []].map(
+    (group) => group.map(normalizeFieldKey)
+  );
+  const matches = names.map((variable) => {
+    if (fields.includes(variable)) {
+      return { variable, field: variable, kind: "exact" };
+    }
+    const key = normalizeFieldKey(variable);
+    const normalized = byKey.get(key);
+    if (normalized !== void 0) {
+      return { variable, field: normalized, kind: "normalized" };
+    }
+    for (const group of groups) {
+      if (!group.includes(key)) continue;
+      for (const alias of group) {
+        const field = byKey.get(alias);
+        if (field !== void 0) return { variable, field, kind: "alias" };
+      }
+    }
+    return { variable, field: null, kind: null };
+  });
+  const mapping = {};
+  for (const match of matches) {
+    Object.defineProperty(mapping, match.variable, {
+      value: match.field,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+  const used = new Set(matches.map((m) => m.field));
+  return {
+    mapping,
+    matches,
+    unmatchedVariables: matches.filter((m) => !m.field).map((m) => m.variable),
+    unusedFields: fields.filter((field) => !used.has(field))
+  };
+}
+function recordToValues(record, mapping = {}, options = {}) {
+  const blankAsMissing = options.blankAsMissing ?? true;
+  const values = {};
+  const assign = (name, value) => {
+    if (value === void 0 || blankAsMissing && value.trim() === "") {
+      delete values[name];
+      return;
+    }
+    Object.defineProperty(values, name, {
+      value,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  };
+  const own = (name) => Object.prototype.hasOwnProperty.call(record, name) ? record[name] : void 0;
+  for (const field of Object.keys(record)) assign(field, record[field]);
+  for (const variable of Object.keys(mapping)) {
+    const field = mapping[variable];
+    if (field === void 0) continue;
+    assign(variable, field === null ? void 0 : own(field));
+  }
+  return values;
+}
+
+// src/grammar/merge.ts
+var MAX_MERGE_OUTPUTS = 1e4;
+var MAX_MERGE_LENGTH = 2e7;
+function isParsedSource(source) {
+  return !!source && typeof source === "object" && !Array.isArray(source) && Array.isArray(source.fields) && Array.isArray(source.records);
+}
+function mergeRecords(template, source, options = {}) {
+  const data = isParsedSource(source) ? source : parseDataSource(source, options.parse);
+  const diagnostics = [];
+  if (!isParsedSource(source)) {
+    for (const warning of data.warnings) {
+      if (warning.code === "empty") continue;
+      diagnostics.push({ code: "data-source", message: warning.message });
+    }
+  }
+  const variables = extractVariables(template, {
+    templates: options.templates,
+    bindings: options.bindings,
+    maxDepth: options.maxDepth
+  });
+  const auto = matchFields(variables, data.fields).mapping;
+  const mapping = { ...auto };
+  for (const [variable, field] of Object.entries(options.mapping ?? {})) {
+    Object.defineProperty(mapping, variable, {
+      value: field,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+  for (const variable of variables) {
+    const field = mapping[variable.name];
+    if ((field === null || field === void 0) && variable.defaultValue === void 0 && variable.usedAsValue) {
+      diagnostics.push({
+        code: "unmapped-variable",
+        message: `No field is mapped to "${variable.name}", so it stays as a placeholder`,
+        name: variable.name
+      });
+    }
+  }
+  let skip;
+  if (typeof options.skipIf === "function") {
+    skip = options.skipIf;
+  } else if (typeof options.skipIf === "string" && options.skipIf.trim()) {
+    const parsed = parseConditionExpression(options.skipIf);
+    if ("error" in parsed) {
+      diagnostics.push({
+        code: "invalid-skip-condition",
+        message: `Invalid skipIf condition "${options.skipIf}": ${parsed.error}`
+      });
+    } else {
+      const field = mapping[parsed.name] ?? matchFields([parsed.name], data.fields).mapping[parsed.name];
+      skip = (record, values) => {
+        if (field && !Object.prototype.hasOwnProperty.call(values, parsed.name) && Object.prototype.hasOwnProperty.call(record, field)) {
+          return evaluateConditionExpression(parsed, {
+            ...values,
+            [parsed.name]: record[field]
+          });
+        }
+        return evaluateConditionExpression(parsed, values);
+      };
+    }
+  }
+  const separator = options.separator === void 0 ? "\n\n" : options.separator === "none" ? "" : options.separator;
+  const maxOutputs = Math.max(0, options.maxOutputs ?? MAX_MERGE_OUTPUTS);
+  const maxLength = Math.max(0, options.maxLength ?? MAX_MERGE_LENGTH);
+  const first = Math.max(1, Math.floor(options.from ?? 1)) - 1;
+  const last = Math.min(
+    data.records.length,
+    Math.floor(options.to ?? data.records.length)
+  );
+  const outputs = [];
+  const skipped = [];
+  let length = 0;
+  let truncated = false;
+  let reportedGrammar = false;
+  for (let index = first; index < last; index++) {
+    const record = data.records[index];
+    const values = recordToValues(record, mapping, {
+      blankAsMissing: options.blankAsMissing
+    });
+    if (skip?.(record, values, index)) {
+      skipped.push({ index, record, reason: "skip-if" });
+      continue;
+    }
+    if (outputs.length >= maxOutputs) {
+      truncated = true;
+      diagnostics.push({
+        code: "max-outputs",
+        message: `Stopped after ${maxOutputs} outputs`
+      });
+      break;
+    }
+    const resolved = resolvePrompt(template, options.templates, {
+      bindings: options.bindings,
+      maxDepth: options.maxDepth,
+      values
+    });
+    if (!reportedGrammar) {
+      reportedGrammar = true;
+      diagnostics.push(...resolved.diagnostics);
+    }
+    const added = resolved.text.length + (outputs.length > 0 ? separator.length : 0);
+    if (length + added > maxLength) {
+      truncated = true;
+      diagnostics.push({
+        code: "max-length",
+        message: `Stopped at ${outputs.length} outputs: the merged text would exceed ${maxLength} characters`
+      });
+      break;
+    }
+    length += added;
+    outputs.push({ index, record, values, text: resolved.text, map: resolved.map });
+  }
+  return {
+    outputs,
+    skipped,
+    diagnostics,
+    text: outputs.map((output) => output.text).join(separator),
+    mapping,
+    truncated
+  };
+}
+function serializeMergeOutputs(outputs, format = "text", separator = "\n\n") {
+  if (format === "json") {
+    return JSON.stringify(
+      outputs.map((output) => ({ record: output.index + 1, text: output.text })),
+      null,
+      2
+    );
+  }
+  return outputs.map((output) => output.text).join(separator === "none" ? "" : separator);
+}
+
+export {
+  resolveTemplates,
+  resolveVariables,
+  extractTemplateNames,
+  extractVariableNames,
+  extractInstructionNames,
+  resolveTemplatesWithMapping,
+  mapResolvedOffsetToRaw,
+  mapRawOffsetToResolved,
+  extractVariables,
+  getVariableFormFields,
+  compactVariableValues,
+  MAX_DATA_SOURCE_RECORDS,
+  MAX_DATA_SOURCE_FIELDS,
+  detectDelimiter,
+  normalizeFieldNames,
+  parseDataSource,
+  normalizeFieldKey,
+  FIELD_ALIASES,
+  matchFields,
+  recordToValues,
+  MAX_MERGE_OUTPUTS,
+  MAX_MERGE_LENGTH,
+  mergeRecords,
+  serializeMergeOutputs
+};
+//# sourceMappingURL=chunk-OXSV64JX.js.map