zustand-querystring 0.4.0 → 0.5.0

package/dist/format/readable.mjs

@@ -1,212 +0,0 @@
-// src/format/readable.ts
-var TYPE_OBJECT = ".";
-var TYPE_ARRAY = "@";
-var TYPE_STRING = "=";
-var TYPE_PRIMITIVE = ":";
-var SEPARATOR = ",";
-var TERMINATOR = "~";
-var ESCAPE = "/";
-var DATE_PREFIX = "D";
-var esc = (c) => /[.$^*+?()[\]{}|\\]/.test(c) ? `\\${c}` : c;
-var KEY_STOP = new RegExp(
-  `[${TYPE_STRING}${TYPE_PRIMITIVE}${TYPE_ARRAY}${esc(TYPE_OBJECT)}${esc(SEPARATOR)}]`
-);
-var VALUE_STOP = new RegExp(`[${esc(SEPARATOR)}${TERMINATOR}]`);
-var KEY_ESCAPE = new RegExp(
-  `([${TYPE_STRING}${TYPE_PRIMITIVE}${TYPE_ARRAY}${esc(TYPE_OBJECT)}${ESCAPE}${esc(SEPARATOR)}])`,
-  "g"
-);
-var VALUE_ESCAPE = new RegExp(
-  `([${esc(SEPARATOR)}${TERMINATOR}${ESCAPE}])`,
-  "g"
-);
-function escapeStr(str, pattern) {
-  return encodeURI(str.replace(pattern, `${ESCAPE}$1`));
-}
-function cleanResult(str, standalone) {
-  while (str.endsWith(TERMINATOR)) str = str.slice(0, -1);
-  const datePattern = new RegExp(`^${esc(TYPE_STRING)}${DATE_PREFIX}-?\\d+$`);
-  if (standalone && datePattern.test(str)) {
-    return str.slice(1);
-  }
-  if (!standalone && str.startsWith(TYPE_OBJECT)) {
-    return str.slice(1);
-  }
-  return str;
-}
-function stringify(value, standalone = false) {
-  return cleanResult(serialize(value, standalone), standalone);
-}
-function serialize(value, standalone, inArray = false) {
-  if (value === null) return `${TYPE_PRIMITIVE}null`;
-  if (value === void 0) return `${TYPE_PRIMITIVE}undefined`;
-  if (typeof value === "function") return "";
-  if (typeof value === "number") {
-    return `${TYPE_PRIMITIVE}${String(value).replace(/\./g, `${ESCAPE}.`)}`;
-  }
-  if (typeof value === "boolean") {
-    return `${TYPE_PRIMITIVE}${value}`;
-  }
-  if (value instanceof Date) {
-    return `${TYPE_STRING}${DATE_PREFIX}${value.getTime()}`;
-  }
-  if (Array.isArray(value)) {
-    const items = value.map((v) => serialize(v, standalone, true));
-    return `${TYPE_ARRAY}${items.join(SEPARATOR)}${TERMINATOR}`;
-  }
-  if (typeof value === "object") {
-    const entries = [];
-    for (const [k, v] of Object.entries(value)) {
-      const val = serialize(v, false, false);
-      if (val || v === void 0) {
-        entries.push(`${escapeStr(k, KEY_ESCAPE)}${val}`);
-      }
-    }
-    return `${TYPE_OBJECT}${entries.join(SEPARATOR)}${TERMINATOR}`;
-  }
-  const strVal = String(value);
-  let escaped = escapeStr(strVal, VALUE_ESCAPE);
-  const datePattern = new RegExp(`^${DATE_PREFIX}-?\\d`);
-  if (datePattern.test(strVal)) {
-    escaped = ESCAPE + escaped;
-  }
-  return standalone || inArray ? escaped : `${TYPE_STRING}${escaped}`;
-}
-function parse(input, standalone = false) {
-  const str = decodeURI(input);
-  if (str.length === 0) {
-    return standalone ? "" : {};
-  }
-  const first = str[0];
-  const hasMarker = first === TYPE_STRING || first === TYPE_PRIMITIVE || first === TYPE_ARRAY || first === TYPE_OBJECT;
-  let source;
-  if (hasMarker) {
-    source = str;
-  } else if (standalone) {
-    const datePattern = new RegExp(`^${DATE_PREFIX}-?\\d+$`);
-    if (datePattern.test(str)) {
-      const timestamp = parseInt(str.slice(DATE_PREFIX.length), 10);
-      if (!isNaN(timestamp)) {
-        return new Date(timestamp);
-      }
-    }
-    return str;
-  } else {
-    const markers = `${TYPE_STRING}${TYPE_PRIMITIVE}${TYPE_ARRAY}${TYPE_OBJECT}`;
-    const objectPattern = new RegExp(
-      `[^${ESCAPE}${markers}${SEPARATOR}${TERMINATOR}][${markers}]`
-    );
-    source = objectPattern.test(str) ? `${TYPE_OBJECT}${str}` : `${TYPE_STRING}${str}`;
-  }
-  let pos = 0;
-  function peek() {
-    return source[pos] || "";
-  }
-  function advance() {
-    pos++;
-  }
-  function readUntil(stopPattern, checkEscape = false) {
-    let result = "";
-    let wasEscaped = false;
-    while (pos < source.length) {
-      const ch = peek();
-      if (ch === ESCAPE) {
-        if (checkEscape && pos + 1 < source.length && source[pos + 1] === DATE_PREFIX) {
-          wasEscaped = true;
-        }
-        advance();
-        if (pos < source.length) {
-          result += peek();
-          advance();
-        }
-        continue;
-      }
-      if (stopPattern.test(ch)) break;
-      result += ch;
-      advance();
-    }
-    return { value: result, wasEscaped };
-  }
-  function parseString() {
-    const { value, wasEscaped } = readUntil(VALUE_STOP, true);
-    const datePattern = new RegExp(`^${DATE_PREFIX}-?\\d+$`);
-    if (!wasEscaped && datePattern.test(value)) {
-      const timestamp = parseInt(value.slice(DATE_PREFIX.length), 10);
-      if (!isNaN(timestamp)) {
-        return new Date(timestamp);
-      }
-    }
-    return value;
-  }
-  function parsePrimitive() {
-    const { value } = readUntil(VALUE_STOP, false);
-    if (value === "null") return null;
-    if (value === "undefined") return void 0;
-    if (value === "true") return true;
-    if (value === "false") return false;
-    return parseFloat(value);
-  }
-  function parseArray() {
-    const result = [];
-    let lastWasSeparator = false;
-    while (pos < source.length && peek() !== TERMINATOR) {
-      if (peek() === SEPARATOR) {
-        result.push("");
-        advance();
-        lastWasSeparator = true;
-        continue;
-      }
-      lastWasSeparator = false;
-      const ch = peek();
-      if (ch === TYPE_PRIMITIVE || ch === TYPE_ARRAY || ch === TYPE_OBJECT || ch === TYPE_STRING) {
-        result.push(parseValue());
-      } else {
-        result.push(parseString());
-      }
-      if (pos < source.length && peek() === SEPARATOR) {
-        advance();
-        lastWasSeparator = true;
-      }
-    }
-    if (lastWasSeparator && (peek() === TERMINATOR || pos >= source.length)) {
-      result.push("");
-    }
-    if (peek() === TERMINATOR) advance();
-    return result;
-  }
-  function parseObject() {
-    const result = {};
-    while (pos < source.length && peek() !== TERMINATOR) {
-      const { value: key } = readUntil(KEY_STOP, false);
-      result[key] = parseValue();
-      if (pos < source.length && peek() !== TERMINATOR && peek() === SEPARATOR) {
-        advance();
-      }
-    }
-    if (peek() === TERMINATOR) advance();
-    return result;
-  }
-  function parseValue() {
-    const type = peek();
-    advance();
-    switch (type) {
-      case TYPE_PRIMITIVE:
-        return parsePrimitive();
-      case TYPE_ARRAY:
-        return parseArray();
-      case TYPE_OBJECT:
-        return parseObject();
-      case TYPE_STRING:
-        return parseString();
-      default:
-        throw new Error(`Unexpected type "${type}" at position ${pos}`);
-    }
-  }
-  return parseValue();
-}
-var readable = { stringify, parse };
-export {
-  parse,
-  readable,
-  stringify
-};