@zenbase/llml/dist/index.cjs

Lightweight Language Markup Language - Convert nested data structures to human-readable, XML-like markup

var import_node_module = require("node:module");
var __create = Object.create;
var __getProtoOf = Object.getPrototypeOf;
var __defProp = Object.defineProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __toESM = (mod, isNodeMode, target) => {
  target = mod != null ? __create(__getProtoOf(mod)) : {};
  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
  for (let key of __getOwnPropNames(mod))
    if (!__hasOwnProp.call(to, key))
      __defProp(to, key, {
        get: () => mod[key],
        enumerable: true
      });
  return to;
};
var __moduleCache = /* @__PURE__ */ new WeakMap;
var __toCommonJS = (from) => {
  var entry = __moduleCache.get(from), desc;
  if (entry)
    return entry;
  entry = __defProp({}, "__esModule", { value: true });
  if (from && typeof from === "object" || typeof from === "function")
    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
      get: () => from[key],
      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
    }));
  __moduleCache.set(from, entry);
  return entry;
};
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, {
      get: all[name],
      enumerable: true,
      configurable: true,
      set: (newValue) => all[name] = () => newValue
    });
};

// src/index.ts
var exports_src = {};
__export(exports_src, {
  llml: () => llml,
  formatters: () => exports_formatters
});
module.exports = __toCommonJS(exports_src);

// src/formatters/index.ts
var exports_formatters = {};
__export(exports_formatters, {
  vibeXML: () => vibeXML,
  json: () => json
});

// src/formatters/base/any.ts
var isAny = (_v) => true;
var formatAny = (value, _llml, _formatters) => String(value);

// src/formatters/json.ts
var json = (replacer, space) => [
  [isAny, (value) => JSON.stringify(value, replacer, space)]
];
// src/formatters/base/boolean.ts
var isBoolean = (v) => typeof v === "boolean";
var formatBoolean = (value, _llml, _formatters) => String(value);

// src/formatters/base/date.ts
var isDate = (v) => v instanceof Date;
var formatDate = (value, _llml, _formatters) => value.toISOString();

// src/formatters/base/null.ts
var isNull = (v) => v === null;
var formatNull = (_value, _llml, _formatters) => "null";

// src/formatters/base/number.ts
var isNumber = (v) => typeof v === "number";
var formatNumber = (value, _llml, _formatters) => String(value);

// src/formatters/base/string.ts
var import_dedent = __toESM(require("dedent"));
var isString = (v) => typeof v === "string";
var formatString = (value, _llml, _formatters) => import_dedent.default(value.trim());

// src/formatters/base/undefined.ts
var isUndefined = (v) => v === undefined;
var formatUndefined = (_value, _llml, _formatters) => "";

// src/formatters/vibe-xml/array.ts
var isArray = (v) => Array.isArray(v);
var formatArray = (unknownValue, llml, formatters) => {
  const value = unknownValue;
  if (value.length === 0)
    return "";
  const results = [];
  for (let i = 0;i < value.length; i++) {
    const item = value[i];
    const itemTag = String(i + 1);
    if (i > 0)
      results.push(`
`);
    if (typeof item === "object" && item !== null && !Array.isArray(item)) {
      const formatted = llml(item, formatters);
      if (formatted.includes(`
`)) {
        results.push(`<${itemTag}>
${formatted}
</${itemTag}>`);
      } else {
        results.push(`<${itemTag}>${formatted}</${itemTag}>`);
      }
    } else {
      const formatted = llml(item, formatters);
      results.push(`<${itemTag}>${formatted}</${itemTag}>`);
    }
  }
  return results.join("");
};

// src/formatters/vibe-xml/object.ts
var import_dedent2 = __toESM(require("dedent"));
var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof Date);
var formatObject = (value, llml, formatters) => {
  if (value && typeof value.toString === "function" && value.toString !== Object.prototype.toString) {
    return value.toString();
  }
  const entries = Object.entries(value);
  if (entries.length === 0) {
    if (Object.getPrototypeOf(value) === Object.prototype) {
      return "";
    }
    return String(value);
  }
  const results = [];
  for (let i = 0;i < entries.length; i++) {
    const [key, val] = entries[i];
    if (i > 0)
      results.push(`
`);
    const formattedContent = formatKeyValue(key, val, llml, formatters);
    results.push(formattedContent);
  }
  return results.join("");
};
function formatKeyValue(key, value, llml, formatters) {
  if (Array.isArray(value)) {
    if (value.length === 0)
      return "";
    const wrapperTag = key;
    let result = `<${wrapperTag}>
`;
    for (let i = 0;i < value.length; i++) {
      const item = value[i];
      const itemTag = `${key}-${i + 1}`;
      if (typeof item === "object" && item !== null && !Array.isArray(item)) {
        const itemFormatted = llml(item, formatters);
        if (itemFormatted.includes(`
`)) {
          result += `  <${itemTag}>
`;
          const indentedContent = itemFormatted.split(`
`).map((line) => line ? `    ${line}` : "").join(`
`);
          result += indentedContent;
          result += `
  </${itemTag}>
`;
        } else {
          result += `  <${itemTag}>${itemFormatted}</${itemTag}>
`;
        }
      } else {
        if (typeof item === "string" && item.includes(`
`)) {
          const cleanText = import_dedent2.default(item).trim();
          const lines = cleanText.split(`
`);
          result += `  <${itemTag}>`;
          for (let j = 0;j < lines.length; j++) {
            if (j > 0) {
              result += `
  `;
            } else {
              result += "  ";
            }
            result += lines[j];
          }
          result += `</${itemTag}>
`;
        } else {
          const formatted2 = llml(item, formatters);
          result += `  <${itemTag}>${formatted2}</${itemTag}>
`;
        }
      }
    }
    result += `</${wrapperTag}>`;
    return result;
  }
  if (typeof value === "object" && value !== null) {
    const formatted2 = llml(value, formatters);
    if (formatted2.includes(`
`)) {
      const indentedContent = formatted2.split(`
`).map((line) => line ? `  ${line}` : "").join(`
`);
      return `<${key}>
${indentedContent}
</${key}>`;
    }
    return `<${key}>${formatted2}</${key}>`;
  }
  if (typeof value === "string" && value.includes(`
`)) {
    const cleanText = import_dedent2.default(value).trim();
    const lines = cleanText.split(`
`);
    const formattedLines = lines.map((line) => `  ${line}`);
    const formattedContent = formattedLines.join(`
`);
    return `<${key}>
${formattedContent}
</${key}>`;
  }
  const formatted = llml(value, formatters);
  return `<${key}>${formatted}</${key}>`;
}

// src/formatters/vibe-xml/index.ts
var defaultVibeXML = new Map([
  [isString, formatString],
  [isNumber, formatNumber],
  [isBoolean, formatBoolean],
  [isUndefined, formatUndefined],
  [isNull, formatNull],
  [isDate, formatDate],
  [isArray, formatArray],
  [isObject, formatObject],
  [isAny, formatAny]
]);
var vibeXML = (options) => {
  if (!options) {
    return defaultVibeXML;
  }
  if (options.formatters) {
    const mergedFormatters = new Map;
    for (const [predicate, formatter] of options.formatters) {
      mergedFormatters.set(predicate, formatter);
    }
    for (const [predicate, formatter] of defaultVibeXML) {
      mergedFormatters.set(predicate, formatter);
    }
    return mergedFormatters;
  }
  return defaultVibeXML;
};
// src/llml.ts
var llml = (data, formatters) => {
  if (data === undefined) {
    return "";
  }
  const activeFormatters = formatters || vibeXML();
  for (const [predicate, formatFunction] of activeFormatters) {
    if (predicate(data)) {
      return formatFunction(data, llml, activeFormatters);
    }
  }
  return String(data);
};