@fluixi/utils 1.0.0-alpha.100

package/dist/lib/primitive/string/parser.cjs

@@ -0,0 +1,236 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/primitive/string/parser.ts
+var parser_exports = {};
+__export(parser_exports, {
+  customParse: () => customParse,
+  parseJsObjectLiteral: () => parseJsObjectLiteral,
+  simpleJsObjectParse: () => simpleJsObjectParse
+});
+module.exports = __toCommonJS(parser_exports);
+function customParse(str, options = {}) {
+  try {
+    return JSON.parse(str);
+  } catch (e) {
+    return parseJsObjectLiteral(str, options);
+  }
+}
+function parseJsObjectLiteral(str, options = {}) {
+  const {
+    allowComments = true,
+    allowUnquotedKeys = true,
+    allowSingleQuotes = true,
+    allowTrailingCommas = true,
+    allowUndefined = false
+  } = options;
+  let fixed = str.trim();
+  if (allowComments) {
+    fixed = fixed.replace(/\/\*[\s\S]*?\*\//g, "");
+    const lines = fixed.split("\n");
+    const cleanedLines = lines.map((line) => {
+      let inString = false;
+      let stringChar = "";
+      let escapeNext = false;
+      for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        if (escapeNext) {
+          escapeNext = false;
+          continue;
+        }
+        if (char === "\\") {
+          escapeNext = true;
+          continue;
+        }
+        if (!inString && (char === '"' || char === "'")) {
+          inString = true;
+          stringChar = char;
+        } else if (inString && char === stringChar) {
+          inString = false;
+          stringChar = "";
+        } else if (!inString && char === "/" && line[i + 1] === "/") {
+          return line.substring(0, i);
+        }
+      }
+      return line;
+    });
+    fixed = cleanedLines.join("\n");
+  }
+  if (allowUnquotedKeys) {
+    fixed = fixed.replace(/([{,]\s*)([a-zA-Z_$][a-zA-Z0-9_$]*)(\s*:)/g, '$1"$2"$3');
+  }
+  if (allowSingleQuotes) {
+    let result = "";
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    let escapeNext = false;
+    let i = 0;
+    while (i < fixed.length) {
+      const char = fixed[i];
+      if (escapeNext) {
+        result += char;
+        escapeNext = false;
+        i++;
+        continue;
+      }
+      if (char === "\\") {
+        escapeNext = true;
+        result += char;
+        i++;
+        continue;
+      }
+      if (char === "'" && !inDoubleQuote) {
+        if (inSingleQuote) {
+          result += '"';
+          inSingleQuote = false;
+        } else {
+          result += '"';
+          inSingleQuote = true;
+        }
+      } else if (char === '"' && !inSingleQuote) {
+        if (inDoubleQuote) {
+          inDoubleQuote = false;
+        } else {
+          inDoubleQuote = true;
+        }
+        result += char;
+      } else {
+        result += char;
+      }
+      i++;
+    }
+    fixed = result;
+  }
+  if (allowTrailingCommas) {
+    let result = "";
+    let inString = false;
+    let stringChar = "";
+    let escapeNext = false;
+    let i = 0;
+    while (i < fixed.length) {
+      const char = fixed[i];
+      if (escapeNext) {
+        result += char;
+        escapeNext = false;
+        i++;
+        continue;
+      }
+      if (char === "\\") {
+        escapeNext = true;
+        result += char;
+        i++;
+        continue;
+      }
+      if ((char === '"' || char === "'") && !inString) {
+        inString = true;
+        stringChar = char;
+        result += char;
+      } else if (inString && char === stringChar) {
+        inString = false;
+        stringChar = "";
+        result += char;
+      } else if (!inString && char === ",") {
+        let j = i + 1;
+        while (j < fixed.length && /\s/.test(fixed[j])) {
+          j++;
+        }
+        if (j < fixed.length && (fixed[j] === "]" || fixed[j] === "}")) {
+          i++;
+          continue;
+        } else {
+          result += char;
+        }
+      } else {
+        result += char;
+      }
+      i++;
+    }
+    fixed = result;
+  }
+  if (allowUndefined) {
+    let result = "";
+    let inString = false;
+    let stringChar = "";
+    let escapeNext = false;
+    let i = 0;
+    while (i < fixed.length) {
+      if (escapeNext) {
+        result += fixed[i];
+        escapeNext = false;
+        i++;
+        continue;
+      }
+      if (fixed[i] === "\\") {
+        escapeNext = true;
+        result += fixed[i];
+        i++;
+        continue;
+      }
+      if ((fixed[i] === '"' || fixed[i] === "'") && !inString) {
+        inString = true;
+        stringChar = fixed[i];
+        result += fixed[i];
+      } else if (inString && fixed[i] === stringChar) {
+        inString = false;
+        stringChar = "";
+        result += fixed[i];
+      } else if (!inString && fixed.substr(i, 9) === "undefined") {
+        const before = i > 0 ? fixed[i - 1] : "";
+        const after = i + 8 < fixed.length ? fixed[i + 9] : "";
+        const isWordChar = /[a-zA-Z0-9_$]/.test(before) || /[a-zA-Z0-9_$]/.test(after);
+        if (!isWordChar) {
+          result += "null";
+          i += 9;
+          continue;
+        } else {
+          result += fixed[i];
+        }
+      } else {
+        result += fixed[i];
+      }
+      i++;
+    }
+    fixed = result;
+  }
+  try {
+    return JSON.parse(fixed);
+  } catch (e) {
+    return void 0;
+  }
+}
+function simpleJsObjectParse(str) {
+  let fixed = str;
+  fixed = fixed.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
+  fixed = fixed.replace(/([{,]\s*)([a-zA-Z_$][\w$]*)(\s*:)/g, (match, prefix, key, suffix) => {
+    if (key === "true" || key === "false" || key === "null" || key === "undefined") {
+      return match;
+    }
+    if (/^\d/.test(key)) {
+      return match;
+    }
+    return `${prefix}"${key}"${suffix}`;
+  });
+  fixed = fixed.replace(/'([^'\\]*(?:\\.[^'\\]*)*)'/g, '"$1"');
+  fixed = fixed.replace(/,(\s*[\]}])/g, "$1");
+  try {
+    return JSON.parse(fixed);
+  } catch (e) {
+    throw new SyntaxError(`Failed to parse JavaScript object literal: ${e}`);
+  }
+}

package/dist/lib/primitive/string/parser.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Fix the regex patterns in the custom parse function
+ * Improved version with proper comment handling
+ */
+declare function customParse(str: string, options?: any): any;
+declare function parseJsObjectLiteral(str: string, options?: any): any;
+declare function simpleJsObjectParse(str: string): any;
+export { customParse, simpleJsObjectParse, parseJsObjectLiteral };
+//# sourceMappingURL=parser.d.ts.map

package/dist/lib/primitive/string/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../../src/lib/primitive/string/parser.ts"],"names":[],"mappings":"AA2iBA;;;GAGG;AACH,iBAAS,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,GAAQ,GAAG,GAAG,CAQxD;AAED,iBAAS,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,GAAQ,GAAG,GAAG,CAoPjE;AAID,iBAAS,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAqC7C;AA4CD,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,CAAC"}