@zenoaihq/tson 1.0.1 → 1.1.0

package/README.md

@@ -455,7 +455,7 @@ MIT License - see [LICENSE](../LICENSE) file for details.
 ---
 
 **Package:** `@zenoaihq/tson`
-**Version:** 1.0.1
+**Version:** 1.1.0
 **Status:** Production Ready
 **Node.js:** 16.0.0+
 **TypeScript:** 5.3+

package/dist/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 // src/utils.ts
-var SPECIAL_CHARS = /* @__PURE__ */ new Set([",", "|", "@", "#", "{", "}", "[", "]", "\n", "\r", "	", " "]);
+var SPECIAL_CHARS = /* @__PURE__ */ new Set([",", "|", "@", "#", "{", "}", "[", "]", "\n", "\r", "	", " ", '"', "(", ")"]);
 function needsQuoting(value) {
   if (value.length === 0) {
     return true;
@@ -33,7 +33,36 @@ function escapeString(value) {
   return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
 }
 function unescapeString(value) {
-  return value.replace(/\\t/g, "	").replace(/\\r/g, "\r").replace(/\\n/g, "\n").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  const result = [];
+  let i = 0;
+  while (i < value.length) {
+    if (value[i] === "\\" && i + 1 < value.length) {
+      const nextChar = value[i + 1];
+      if (nextChar === "\\") {
+        result.push("\\");
+        i += 2;
+      } else if (nextChar === '"') {
+        result.push('"');
+        i += 2;
+      } else if (nextChar === "n") {
+        result.push("\n");
+        i += 2;
+      } else if (nextChar === "r") {
+        result.push("\r");
+        i += 2;
+      } else if (nextChar === "t") {
+        result.push("	");
+        i += 2;
+      } else {
+        result.push(value[i]);
+        i += 1;
+      }
+    } else {
+      result.push(value[i]);
+      i += 1;
+    }
+  }
+  return result.join("");
 }
 function formatPrimitive(value) {
   if (value === null) {
@@ -162,11 +191,11 @@ function splitByDelimiter(text, delimiter) {
 }
 function parseKeySchema(keyString) {
   const trimmed = keyString.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return { keyName: unescapeString(trimmed.slice(1, -1)), schema: null, count: null };
+  }
   if (!trimmed.includes("(")) {
-    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
-      return { keyName: unescapeString(trimmed.slice(1, -1)), schema: null };
-    }
-    return { keyName: trimmed, schema: null };
+    return { keyName: trimmed, schema: null, count: null };
   }
   const parenIdx = trimmed.indexOf("(");
   let keyName = trimmed.slice(0, parenIdx).trim();
@@ -180,14 +209,54 @@ function parseKeySchema(keyString) {
   if (schemaStr.startsWith("@")) {
     schemaStr = schemaStr.slice(1);
   }
+  let nestedCount = null;
+  const hashIdx = findTrailingHash(schemaStr);
+  if (hashIdx !== -1) {
+    const countPart = schemaStr.slice(hashIdx + 1).trim();
+    const parsedCount = parseInt(countPart, 10);
+    if (!isNaN(parsedCount)) {
+      nestedCount = parsedCount;
+      schemaStr = schemaStr.slice(0, hashIdx).trim();
+    }
+  }
   const schemaKeys = splitByDelimiter(schemaStr, ",");
-  return { keyName, schema: schemaKeys };
+  return { keyName, schema: schemaKeys, count: nestedCount };
+}
+function findTrailingHash(schemaStr) {
+  let inQuotes = false;
+  let depthParen = 0;
+  for (let i = schemaStr.length - 1; i >= 0; i--) {
+    const char = schemaStr[i];
+    if (char === '"') {
+      let backslashCount = 0;
+      for (let j = i - 1; j >= 0; j--) {
+        if (schemaStr[j] === "\\") {
+          backslashCount++;
+        } else {
+          break;
+        }
+      }
+      if (backslashCount % 2 === 0) {
+        inQuotes = !inQuotes;
+      }
+    }
+    if (!inQuotes) {
+      if (char === ")") {
+        depthParen++;
+      } else if (char === "(") {
+        depthParen--;
+      } else if (char === "#" && depthParen === 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
 }
 function buildSchemaMap(keys) {
   const schemaMap = {};
   for (const key of keys) {
-    const { keyName, schema } = parseKeySchema(key);
-    schemaMap[keyName] = schema;
+    const { keyName, schema, count } = parseKeySchema(key);
+    schemaMap[keyName] = { schema, count };
   }
   return schemaMap;
 }
@@ -302,9 +371,21 @@ function serializeTabular(arr) {
       keyStr = `"${escapeString(keyStr)}"`;
     }
     if (key in nestedSchemas) {
-      const schemaKeys = nestedSchemas[key];
-      const schemaStr = schemaKeys.join(",");
-      keyStr = `${keyStr}(@${schemaStr})`;
+      const schemaInfo = nestedSchemas[key];
+      const schemaKeys = schemaInfo.schema;
+      const nestedCount = schemaInfo.count;
+      const formattedSchemaKeys = schemaKeys.map((sk) => {
+        if (needsQuoting(sk)) {
+          return `"${escapeString(sk)}"`;
+        }
+        return sk;
+      });
+      const schemaStr = formattedSchemaKeys.join(",");
+      if (nestedCount !== null) {
+        keyStr = `${keyStr}(@${schemaStr}#${nestedCount})`;
+      } else {
+        keyStr = `${keyStr}(@${schemaStr})`;
+      }
     }
     keyParts.push(keyStr);
   }
@@ -315,7 +396,12 @@ function serializeTabular(arr) {
     for (const key of keys) {
       const value = obj[key];
       if (key in nestedSchemas) {
-        valueParts.push(serializeSchematizedObject(value, nestedSchemas[key]));
+        const schemaInfo = nestedSchemas[key];
+        if (schemaInfo.count !== null) {
+          valueParts.push(serializeSchematizedArray(value, schemaInfo.schema));
+        } else {
+          valueParts.push(serializeSchematizedObject(value, schemaInfo.schema));
+        }
       } else {
         valueParts.push(serializeValue(value));
       }
@@ -329,19 +415,49 @@ function detectNestedSchemas(arr, keys) {
   const nestedSchemas = {};
   for (const key of keys) {
     const values = arr.map((obj) => obj[key]);
-    if (!values.every((v) => typeof v === "object" && v !== null && !Array.isArray(v))) {
-      continue;
-    }
-    if (values.length === 0) {
+    if (values.every((v) => typeof v === "object" && v !== null && !Array.isArray(v))) {
+      if (values.length === 0) {
+        continue;
+      }
+      const firstKeys = Object.keys(values[0]);
+      const allSame = values.slice(1).every((v) => {
+        const objKeys = Object.keys(v);
+        return objKeys.length === firstKeys.length && objKeys.every((k, i) => k === firstKeys[i]);
+      });
+      if (allSame) {
+        nestedSchemas[key] = { schema: firstKeys, count: null };
+      }
       continue;
     }
-    const firstKeys = Object.keys(values[0]);
-    const allSame = values.slice(1).every((v) => {
-      const objKeys = Object.keys(v);
-      return objKeys.length === firstKeys.length && objKeys.every((k, i) => k === firstKeys[i]);
-    });
-    if (allSame) {
-      nestedSchemas[key] = firstKeys;
+    if (values.every((v) => Array.isArray(v))) {
+      if (values.length === 0) {
+        continue;
+      }
+      let allUniform = true;
+      let firstSchema = null;
+      let arrayCount = null;
+      for (const v of values) {
+        const arr2 = v;
+        if (!isUniformObjectArray(arr2)) {
+          allUniform = false;
+          break;
+        }
+        if (arr2.length === 0) {
+          continue;
+        }
+        const vSchema = Object.keys(arr2[0]);
+        const vCount = arr2.length;
+        if (firstSchema === null) {
+          firstSchema = vSchema;
+          arrayCount = vCount;
+        } else if (vSchema.length !== firstSchema.length || !vSchema.every((k, i) => k === firstSchema[i]) || vCount !== arrayCount) {
+          allUniform = false;
+          break;
+        }
+      }
+      if (allUniform && firstSchema !== null) {
+        nestedSchemas[key] = { schema: firstSchema, count: arrayCount };
+      }
     }
   }
   return nestedSchemas;
@@ -357,6 +473,16 @@ function serializeSchematizedObject(obj, schema) {
   }
   return "{" + valueParts.join(",") + "}";
 }
+function serializeSchematizedArray(arr, schema) {
+  if (arr.length === 0) {
+    return "[]";
+  }
+  const objParts = [];
+  for (const obj of arr) {
+    objParts.push(serializeSchematizedObject(obj, schema));
+  }
+  return "[" + objParts.join(",") + "]";
+}
 
 // src/deserializer.ts
 function loads(s) {
@@ -409,8 +535,14 @@ function parseKeyedObject(content) {
   }
   const keysPart = parts[0];
   const { keys, count } = parseKeys(keysPart);
+  if (keys.length === 0 && count !== null) {
+    return Array.from({ length: count }, () => ({}));
+  }
   const schemaMap = buildSchemaMap(keys);
   const fieldNames = keys.map((k) => parseKeySchema(k).keyName);
+  if (keys.length === 0) {
+    return {};
+  }
   if (parts.length === 1) {
     throw new Error("Invalid object format: missing values");
   }
@@ -433,9 +565,11 @@ function parseSingleObject(fieldNames, valuesStr, schemaMap) {
   for (let i = 0; i < fieldNames.length; i++) {
     const fieldName = fieldNames[i];
     const valueStr = values[i];
-    const schema = schemaMap[fieldName];
+    const schemaInfo = schemaMap[fieldName];
+    const schema = schemaInfo?.schema;
+    const count = schemaInfo?.count;
     if (schema) {
-      obj[fieldName] = parseSchematizedValue(valueStr, schema);
+      obj[fieldName] = parseSchematizedValue(valueStr, schema, count);
     } else {
       obj[fieldName] = parseValue(valueStr);
     }
@@ -458,7 +592,36 @@ function parseTabularArray(fieldNames, rowParts, schemaMap, expectedCount) {
   }
   return result;
 }
-function parseSchematizedValue(valueStr, schema) {
+function parseSchematizedValue(valueStr, schema, expectedCount = null) {
+  const trimmed = valueStr.trim();
+  if (expectedCount !== null) {
+    return parseSchematizedArray(trimmed, schema, expectedCount);
+  }
+  return parseSingleSchematizedObject(trimmed, schema);
+}
+function parseSchematizedArray(valueStr, schema, expectedCount) {
+  const trimmed = valueStr.trim();
+  if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) {
+    throw new Error(`Schematized array must be wrapped in brackets: ${valueStr}`);
+  }
+  const content = trimmed.slice(1, -1).trim();
+  if (content.length === 0) {
+    return [];
+  }
+  const parts = splitByDelimiter(content, ",");
+  if (parts.length !== expectedCount) {
+    throw new Error(
+      `Array count mismatch: expected ${expectedCount} objects but got ${parts.length}`
+    );
+  }
+  const result = [];
+  for (const part of parts) {
+    const obj = parseSingleSchematizedObject(part.trim(), schema);
+    result.push(obj);
+  }
+  return result;
+}
+function parseSingleSchematizedObject(valueStr, schema) {
   const trimmed = valueStr.trim();
   if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
     throw new Error(`Schematized value must be wrapped in braces: ${valueStr}`);
@@ -478,12 +641,14 @@ function parseSchematizedValue(valueStr, schema) {
   const obj = {};
   for (let i = 0; i < fieldNames.length; i++) {
     const fieldName = fieldNames[i];
-    const valueStr2 = values[i];
-    const nestedSchema = nestedSchemaMap[fieldName];
+    const valStr = values[i];
+    const schemaInfo = nestedSchemaMap[fieldName];
+    const nestedSchema = schemaInfo?.schema;
+    const nestedCount = schemaInfo?.count;
     if (nestedSchema) {
-      obj[fieldName] = parseSchematizedValue(valueStr2, nestedSchema);
+      obj[fieldName] = parseSchematizedValue(valStr, nestedSchema, nestedCount);
     } else {
-      obj[fieldName] = parseValue(valueStr2);
+      obj[fieldName] = parseValue(valStr);
     }
   }
   return obj;
@@ -507,20 +672,228 @@ function parseArray(text) {
   return result;
 }
 
+// src/prettify.ts
+function prettify(tsonStr, indent = "  ") {
+  if (!tsonStr || !tsonStr.trim()) {
+    return tsonStr;
+  }
+  return prettifyValue(tsonStr.trim(), indent, 0);
+}
+function minify(tsonStr) {
+  if (!tsonStr) {
+    return tsonStr;
+  }
+  const lines = tsonStr.split("\n");
+  const result = [];
+  for (const line of lines) {
+    result.push(line.trim());
+  }
+  return result.join("");
+}
+function prettifyValue(text, indent, depth) {
+  text = text.trim();
+  if (!text) {
+    return text;
+  }
+  if (text.startsWith("{@")) {
+    return prettifyObject(text, indent, depth);
+  }
+  if (text.startsWith("{")) {
+    return text;
+  }
+  if (text.startsWith("[")) {
+    return prettifyArray(text, indent, depth);
+  }
+  return text;
+}
+function prettifyObject(text, indent, depth) {
+  if (!text.startsWith("{@") || !text.endsWith("}")) {
+    return text;
+  }
+  const content = text.slice(2, -1);
+  if (!content) {
+    return "{@}";
+  }
+  const parts = splitTopLevel(content, "|");
+  if (parts.length === 0) {
+    return text;
+  }
+  const schema = parts[0];
+  const valueRows = parts.slice(1);
+  const nextIndent = indent.repeat(depth + 1);
+  if (valueRows.length === 0) {
+    return `{@${schema}}`;
+  }
+  const lines = [`{@${schema}`];
+  for (const row of valueRows) {
+    lines.push(`${nextIndent}|${row}`);
+  }
+  lines[lines.length - 1] = lines[lines.length - 1] + "}";
+  return lines.join("\n");
+}
+function prettifyArray(text, indent, depth) {
+  if (!text.startsWith("[") || !text.endsWith("]")) {
+    return text;
+  }
+  const content = text.slice(1, -1);
+  if (!content) {
+    return "[]";
+  }
+  const elements = splitTopLevel(content, ",");
+  if (elements.length <= 1) {
+    return text;
+  }
+  const nextIndent = indent.repeat(depth + 1);
+  const lines = [];
+  for (let i = 0; i < elements.length; i++) {
+    const prettified = prettifyValue(elements[i].trim(), indent, depth + 1);
+    if (i === 0) {
+      lines.push(`[${prettified}`);
+    } else {
+      lines.push(`${nextIndent},${prettified}`);
+    }
+  }
+  lines[lines.length - 1] = lines[lines.length - 1] + "]";
+  return lines.join("\n");
+}
+function splitTopLevel(text, delimiter) {
+  const parts = [];
+  const current = [];
+  let depth = 0;
+  let inString = false;
+  let escapeNext = false;
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    if (escapeNext) {
+      current.push(char);
+      escapeNext = false;
+      continue;
+    }
+    if (char === "\\") {
+      current.push(char);
+      escapeNext = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      current.push(char);
+      continue;
+    }
+    if (inString) {
+      current.push(char);
+      continue;
+    }
+    if (char === "{" || char === "[") {
+      depth++;
+      current.push(char);
+    } else if (char === "}" || char === "]") {
+      depth--;
+      current.push(char);
+    } else if (char === delimiter && depth === 0) {
+      parts.push(current.join(""));
+      current.length = 0;
+    } else {
+      current.push(char);
+    }
+  }
+  if (current.length > 0) {
+    parts.push(current.join(""));
+  }
+  return parts;
+}
+
+// src/fileio.ts
+async function loadJson(filepath) {
+  const fs = await import('fs/promises');
+  const content = await fs.readFile(filepath, "utf-8");
+  return JSON.parse(content);
+}
+async function loadTson(filepath) {
+  const fs = await import('fs/promises');
+  const content = await fs.readFile(filepath, "utf-8");
+  return loads(content);
+}
+async function saveTson(data, filepath, options = {}) {
+  const fs = await import('fs/promises');
+  let tsonStr = dumps(data);
+  if (options.format === "pretty") {
+    tsonStr = prettify(tsonStr, options.indent || "  ");
+  }
+  await fs.writeFile(filepath, tsonStr, "utf-8");
+}
+async function saveTsonString(tsonStr, filepath, options = {}) {
+  const fs = await import('fs/promises');
+  if (options.format === "pretty") {
+    tsonStr = prettify(tsonStr, options.indent || "  ");
+  } else if (options.format === "compact") {
+    tsonStr = minify(tsonStr);
+  }
+  await fs.writeFile(filepath, tsonStr, "utf-8");
+}
+async function jsonToTson(inputPath, outputPath, options = {}) {
+  const data = await loadJson(inputPath);
+  let tsonStr = dumps(data);
+  if (options.format === "pretty") {
+    tsonStr = prettify(tsonStr);
+  }
+  if (outputPath) {
+    await saveTsonString(tsonStr, outputPath);
+  }
+  return tsonStr;
+}
+async function tsonToJson(inputPath, outputPath, options = {}) {
+  const data = await loadTson(inputPath);
+  const jsonStr = JSON.stringify(data, null, options.indent ?? 2);
+  if (outputPath) {
+    const fs = await import('fs/promises');
+    await fs.writeFile(outputPath, jsonStr, "utf-8");
+  }
+  return jsonStr;
+}
+async function readTsonString(filepath) {
+  const fs = await import('fs/promises');
+  return fs.readFile(filepath, "utf-8");
+}
+async function prettifyFile(inputPath, outputPath, indent = "  ") {
+  const tsonStr = await readTsonString(inputPath);
+  const prettyStr = prettify(tsonStr, indent);
+  const target = outputPath || inputPath;
+  await saveTsonString(prettyStr, target);
+  return prettyStr;
+}
+async function minifyFile(inputPath, outputPath) {
+  const tsonStr = await readTsonString(inputPath);
+  const compactStr = minify(tsonStr);
+  const target = outputPath || inputPath;
+  await saveTsonString(compactStr, target);
+  return compactStr;
+}
+
 exports.buildSchemaMap = buildSchemaMap;
 exports.dump = dump;
 exports.dumps = dumps;
 exports.escapeString = escapeString;
 exports.formatPrimitive = formatPrimitive;
 exports.isUniformObjectArray = isUniformObjectArray;
+exports.jsonToTson = jsonToTson;
 exports.load = load;
+exports.loadJson = loadJson;
+exports.loadTson = loadTson;
 exports.loads = loads;
 exports.looksLikeNumber = looksLikeNumber;
+exports.minify = minify;
+exports.minifyFile = minifyFile;
 exports.needsQuoting = needsQuoting;
 exports.parseKeySchema = parseKeySchema;
 exports.parseKeys = parseKeys;
 exports.parsePrimitive = parsePrimitive;
+exports.prettify = prettify;
+exports.prettifyFile = prettifyFile;
+exports.readTsonString = readTsonString;
+exports.saveTson = saveTson;
+exports.saveTsonString = saveTsonString;
 exports.splitByDelimiter = splitByDelimiter;
+exports.tsonToJson = tsonToJson;
 exports.unescapeString = unescapeString;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map