zustand-querystring 0.4.1 → 0.6.0

package/dist/index.js

@@ -19,23 +19,368 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  createURL: () => createURL,
-  parse: () => parse,
-  querystring: () => querystring,
-  stringify: () => stringify
+  querystring: () => querystring
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/middleware.ts
 var import_lodash_es = require("lodash-es");
 
-// src/parser.ts
-function stringify(input) {
-  return encodeURIComponent(JSON.stringify(input));
+// src/format/marked.ts
+function resolveOptions(opts = {}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  return {
+    typeObject: (_a = opts.typeObject) != null ? _a : ".",
+    typeArray: (_b = opts.typeArray) != null ? _b : "@",
+    typeString: (_c = opts.typeString) != null ? _c : "=",
+    typePrimitive: (_d = opts.typePrimitive) != null ? _d : ":",
+    separator: (_e = opts.separator) != null ? _e : ",",
+    terminator: (_f = opts.terminator) != null ? _f : "~",
+    escape: (_g = opts.escapeChar) != null ? _g : "_",
+    datePrefix: (_h = opts.datePrefix) != null ? _h : "D"
+  };
+}
+function validateOptions(opts) {
+  const tokens = [
+    opts.typeObject,
+    opts.typeArray,
+    opts.typeString,
+    opts.typePrimitive,
+    opts.separator,
+    opts.terminator,
+    opts.escape
+  ];
+  for (const token of tokens) {
+    if (token.length === 0) {
+      throw new Error("All tokens must be non-empty strings");
+    }
+  }
+  if (opts.datePrefix.length === 0) {
+    throw new Error("datePrefix must be non-empty");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const token of tokens) {
+    if (seen.has(token)) {
+      throw new Error(`Duplicate token detected: '${token}'`);
+    }
+    seen.add(token);
+  }
+  if (seen.has(opts.datePrefix)) {
+    throw new Error(`datePrefix '${opts.datePrefix}' conflicts with another token`);
+  }
+}
+function escapeRegex(str) {
+  return str.replace(/[.$^*+?()[\]{}|\\-]/g, "\\$&");
+}
+function buildKeyStopPattern(opts) {
+  return new RegExp(
+    `[${escapeRegex(opts.typeString)}${escapeRegex(opts.typePrimitive)}${escapeRegex(opts.typeArray)}${escapeRegex(opts.typeObject)}${escapeRegex(opts.separator)}]`
+  );
+}
+function buildValueStopPattern(opts) {
+  return new RegExp(`[${escapeRegex(opts.separator)}${escapeRegex(opts.terminator)}]`);
+}
+function buildKeyEscapePattern(opts) {
+  return new RegExp(
+    `([${escapeRegex(opts.typeString)}${escapeRegex(opts.typePrimitive)}${escapeRegex(opts.typeArray)}${escapeRegex(opts.typeObject)}${escapeRegex(opts.separator)}])`,
+    "g"
+  );
+}
+function buildValueEscapePattern(opts) {
+  return new RegExp(`([${escapeRegex(opts.separator)}${escapeRegex(opts.terminator)}])`, "g");
+}
+function buildDatePattern(opts) {
+  return new RegExp(`^${escapeRegex(opts.datePrefix)}-?\\d+$`);
+}
+function buildDateStartPattern(opts) {
+  return new RegExp(`^${escapeRegex(opts.datePrefix)}-?\\d`);
 }
-function parse(str) {
-  return JSON.parse(decodeURIComponent(str));
+function encodePreservingMarkers(str, opts) {
+  const markers = /* @__PURE__ */ new Set([
+    opts.typeObject,
+    opts.typeArray,
+    opts.typeString,
+    opts.typePrimitive,
+    opts.separator,
+    opts.terminator,
+    opts.escape
+  ]);
+  let result = "";
+  for (const char of str) {
+    if (markers.has(char)) {
+      result += char;
+    } else {
+      result += encodeURIComponent(char);
+    }
+  }
+  return result;
+}
+function escapeStr(str, pattern, escape, opts) {
+  return encodePreservingMarkers(str.replace(pattern, `${escape}$1`), opts);
+}
+function cleanResult(str, standalone, opts) {
+  while (str.endsWith(opts.terminator)) {
+    str = str.slice(0, -opts.terminator.length);
+  }
+  const datePattern = new RegExp(`^${escapeRegex(opts.typeString)}${escapeRegex(opts.datePrefix)}-?\\d+$`);
+  if (standalone && datePattern.test(str)) {
+    return str.slice(opts.typeString.length);
+  }
+  if (!standalone && str.startsWith(opts.typeObject)) {
+    return str.slice(opts.typeObject.length);
+  }
+  return str;
+}
+function createSerializer(opts) {
+  const keyEscape = buildKeyEscapePattern(opts);
+  const valueEscape = buildValueEscapePattern(opts);
+  const dateStartPattern = buildDateStartPattern(opts);
+  function serialize(value, standalone, inArray = false) {
+    if (value === null) return `${opts.typePrimitive}null`;
+    if (value === void 0) return `${opts.typePrimitive}undefined`;
+    if (typeof value === "function") return "";
+    if (typeof value === "number") {
+      return `${opts.typePrimitive}${value}`;
+    }
+    if (typeof value === "boolean") {
+      return `${opts.typePrimitive}${value}`;
+    }
+    if (value instanceof Date) {
+      return `${opts.typeString}${opts.datePrefix}${value.getTime()}`;
+    }
+    if (Array.isArray(value)) {
+      const items = value.map((v) => serialize(v, standalone, true));
+      return `${opts.typeArray}${items.join(opts.separator)}${opts.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, keyEscape, opts.escape, opts)}${val}`);
+        }
+      }
+      return `${opts.typeObject}${entries.join(opts.separator)}${opts.terminator}`;
+    }
+    const strVal = String(value);
+    let escaped = escapeStr(strVal, valueEscape, opts.escape, opts);
+    if (dateStartPattern.test(strVal)) {
+      escaped = opts.escape + escaped;
+    } else if ((standalone || inArray) && (strVal.startsWith(opts.typeObject) || strVal.startsWith(opts.typeArray) || strVal.startsWith(opts.typePrimitive) || strVal.startsWith(opts.typeString))) {
+      escaped = opts.escape + escaped;
+    }
+    return standalone || inArray ? escaped : `${opts.typeString}${escaped}`;
+  }
+  return serialize;
 }
+function createParser(opts) {
+  const keyStop = buildKeyStopPattern(opts);
+  const valueStop = buildValueStopPattern(opts);
+  const datePattern = buildDatePattern(opts);
+  const tokens = {
+    typePrimitive: opts.typePrimitive,
+    typeArray: opts.typeArray,
+    typeObject: opts.typeObject,
+    typeString: opts.typeString,
+    separator: opts.separator,
+    terminator: opts.terminator,
+    escape: opts.escape,
+    datePrefix: opts.datePrefix
+  };
+  return function parseSource(source) {
+    let pos = 0;
+    function peek(len = 1) {
+      return source.slice(pos, pos + len);
+    }
+    function startsWith(token) {
+      return source.slice(pos, pos + token.length) === token;
+    }
+    function advance(len = 1) {
+      pos += len;
+    }
+    function readUntil(stopPattern, checkEscape = false) {
+      let result = "";
+      let wasEscaped = false;
+      while (pos < source.length) {
+        if (startsWith(tokens.escape)) {
+          const nextPos = pos + tokens.escape.length;
+          const nextChar = source.slice(nextPos, nextPos + 1);
+          const isEscapeSequence = stopPattern.test(nextChar);
+          const isDateEscape = checkEscape && source.slice(nextPos, nextPos + tokens.datePrefix.length) === tokens.datePrefix;
+          if (isEscapeSequence || isDateEscape) {
+            if (isDateEscape) {
+              wasEscaped = true;
+            }
+            advance(tokens.escape.length);
+            if (pos < source.length) {
+              result += peek();
+              advance();
+            }
+            continue;
+          }
+        }
+        const ch = peek();
+        if (stopPattern.test(ch)) break;
+        result += ch;
+        advance();
+      }
+      return { value: result, wasEscaped };
+    }
+    function parseString() {
+      const { value, wasEscaped } = readUntil(valueStop, true);
+      if (!wasEscaped && datePattern.test(value)) {
+        const timestamp = parseInt(value.slice(tokens.datePrefix.length), 10);
+        if (!isNaN(timestamp)) {
+          return new Date(timestamp);
+        }
+      }
+      return value;
+    }
+    function parsePrimitive() {
+      const { value } = readUntil(valueStop, 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 && !startsWith(tokens.terminator)) {
+        if (startsWith(tokens.separator)) {
+          result.push("");
+          advance(tokens.separator.length);
+          lastWasSeparator = true;
+          continue;
+        }
+        lastWasSeparator = false;
+        if (startsWith(tokens.typePrimitive) || startsWith(tokens.typeArray) || startsWith(tokens.typeObject) || startsWith(tokens.typeString)) {
+          result.push(parseValue());
+        } else {
+          result.push(parseString());
+        }
+        if (pos < source.length && startsWith(tokens.separator)) {
+          advance(tokens.separator.length);
+          lastWasSeparator = true;
+        }
+      }
+      if (lastWasSeparator && (startsWith(tokens.terminator) || pos >= source.length)) {
+        result.push("");
+      }
+      if (startsWith(tokens.terminator)) advance(tokens.terminator.length);
+      return result;
+    }
+    function parseObject() {
+      const result = {};
+      while (pos < source.length && !startsWith(tokens.terminator)) {
+        const { value: key } = readUntil(keyStop, false);
+        result[key] = parseValue();
+        if (pos < source.length && !startsWith(tokens.terminator) && startsWith(tokens.separator)) {
+          advance(tokens.separator.length);
+        }
+      }
+      if (startsWith(tokens.terminator)) advance(tokens.terminator.length);
+      return result;
+    }
+    function parseValue() {
+      if (startsWith(tokens.typePrimitive)) {
+        advance(tokens.typePrimitive.length);
+        return parsePrimitive();
+      }
+      if (startsWith(tokens.typeArray)) {
+        advance(tokens.typeArray.length);
+        return parseArray();
+      }
+      if (startsWith(tokens.typeObject)) {
+        advance(tokens.typeObject.length);
+        return parseObject();
+      }
+      if (startsWith(tokens.typeString)) {
+        advance(tokens.typeString.length);
+        return parseString();
+      }
+      throw new Error(`Unexpected type "${peek()}" at position ${pos}`);
+    }
+    return parseValue();
+  };
+}
+function stringify(value, standalone = false, options = {}) {
+  const opts = resolveOptions(options);
+  const serialize = createSerializer(opts);
+  return cleanResult(serialize(value, standalone), standalone, opts);
+}
+function parse(input, standalone = false, options = {}) {
+  const opts = resolveOptions(options);
+  const datePattern = buildDatePattern(opts);
+  const str = decodeURIComponent(input);
+  if (str.length === 0) {
+    return standalone ? "" : {};
+  }
+  const hasMarker = str.startsWith(opts.typeString) || str.startsWith(opts.typePrimitive) || str.startsWith(opts.typeArray) || str.startsWith(opts.typeObject);
+  let source;
+  if (hasMarker) {
+    source = str;
+  } else if (standalone) {
+    if (datePattern.test(str)) {
+      const timestamp = parseInt(str.slice(opts.datePrefix.length), 10);
+      if (!isNaN(timestamp)) {
+        return new Date(timestamp);
+      }
+    }
+    let result = "";
+    for (let i = 0; i < str.length; i++) {
+      if (str.slice(i, i + opts.escape.length) === opts.escape && i + opts.escape.length < str.length) {
+        i += opts.escape.length - 1;
+        result += str[i + 1];
+        i++;
+      } else {
+        result += str[i];
+      }
+    }
+    return result;
+  } else {
+    const escapedMarkers = [opts.typeString, opts.typePrimitive, opts.typeArray, opts.typeObject].map(escapeRegex).join("");
+    const escapedEscape = escapeRegex(opts.escape);
+    const escapedSeparator = escapeRegex(opts.separator);
+    const escapedTerminator = escapeRegex(opts.terminator);
+    const objectPattern = new RegExp(
+      `[^${escapedEscape}${escapedMarkers}${escapedSeparator}${escapedTerminator}][${escapedMarkers}]`
+    );
+    source = objectPattern.test(str) ? `${opts.typeObject}${str}` : `${opts.typeString}${str}`;
+  }
+  const parseSource = createParser(opts);
+  return parseSource(source);
+}
+function createFormat(options = {}) {
+  const opts = resolveOptions(options);
+  validateOptions(opts);
+  return {
+    stringify(state) {
+      return stringify(state, false, options);
+    },
+    parse(value, _ctx) {
+      return parse(value, false, options);
+    },
+    stringifyStandalone(state) {
+      const result = {};
+      for (const [key, value] of Object.entries(state)) {
+        result[encodeURIComponent(key)] = [stringify(value, true, options)];
+      }
+      return result;
+    },
+    parseStandalone(params, _ctx) {
+      const result = {};
+      for (const [key, values] of Object.entries(params)) {
+        if (values.length > 0) {
+          result[decodeURIComponent(key)] = parse(values[0], true, options);
+        }
+      }
+      return result;
+    }
+  };
+}
+var marked = createFormat();
 
 // src/middleware.ts
 var compact = (newState, initialState, syncNull = false, syncUndefined = false) => {
@@ -79,55 +424,60 @@ var translateSelectionToState = (selection, state) => {
     return acc;
   }, {});
 };
+var parseSearchString = (search) => {
+  const result = {};
+  search.slice(search.startsWith("?") ? 1 : 0).split("&").filter(Boolean).forEach((param) => {
+    const eqIndex = param.indexOf("=");
+    if (eqIndex === -1) return;
+    const key = param.slice(0, eqIndex);
+    const value = param.slice(eqIndex + 1);
+    if (!result[key]) {
+      result[key] = [];
+    }
+    result[key].push(value);
+  });
+  return result;
+};
 var queryStringImpl = (fn, options) => (set, get, api) => {
   const defaultedOptions = {
-    key: "state",
-    format: {
-      stringify,
-      parse
-    },
+    key: false,
+    prefix: "",
+    format: marked,
     syncNull: false,
     syncUndefined: false,
     ...options
   };
-  const standalone = !defaultedOptions.key;
-  if (typeof window !== "undefined" && standalone) {
-    if (!window.__ZUSTAND_QUERYSTRING_KEYS__) {
-      window.__ZUSTAND_QUERYSTRING_KEYS__ = /* @__PURE__ */ new Map();
-    }
+  if (defaultedOptions.prefix === void 0) {
+    defaultedOptions.prefix = "";
   }
+  const format = defaultedOptions.format;
+  const standalone = defaultedOptions.key === false;
   const getStateFromUrl = (url, initialState) => {
+    const params = parseSearchString(url.search);
     if (standalone) {
-      const params2 = url.search.slice(1).split("&").filter(Boolean);
-      const state = {};
-      const initialKeys = new Set(Object.keys(initialState));
-      params2.forEach((param) => {
-        const eqIndex = param.indexOf("=");
-        if (eqIndex === -1) return;
-        const key = decodeURI(param.slice(0, eqIndex));
-        const value = param.slice(eqIndex + 1);
-        if (!initialKeys.has(key)) return;
+      let filteredParams = params;
+      if (defaultedOptions.prefix) {
+        filteredParams = {};
+        for (const [key, values] of Object.entries(params)) {
+          if (key.startsWith(defaultedOptions.prefix)) {
+            filteredParams[key.slice(defaultedOptions.prefix.length)] = values;
+          }
+        }
+      }
+      const result = format.parseStandalone(filteredParams, { initialState });
+      return Object.keys(result).length > 0 ? result : null;
+    } else {
+      const fullKey = defaultedOptions.prefix + defaultedOptions.key;
+      const values = params[fullKey];
+      if (values && values.length > 0) {
         try {
-          const parsed = defaultedOptions.format.parse(value, true);
-          state[key] = parsed;
-        } catch (error) {
-          console.error("[getStateFromUrl] error parsing key:", key, error);
+          return format.parse(values[0], { initialState });
+        } catch {
+          return null;
         }
-      });
-      return Object.keys(state).length > 0 ? state : null;
-    }
-    const params = url.search.slice(1).split("&");
-    for (const param of params) {
-      const eqIndex = param.indexOf("=");
-      if (eqIndex === -1) continue;
-      const key = param.slice(0, eqIndex);
-      if (key === defaultedOptions.key) {
-        const value = param.slice(eqIndex + 1);
-        const parsed = value ? defaultedOptions.format.parse(value, false) : null;
-        return parsed;
       }
+      return null;
     }
-    return null;
   };
   const getSelectedState = (state, pathname) => {
     if (defaultedOptions.select) {
@@ -139,11 +489,11 @@ var queryStringImpl = (fn, options) => (set, get, api) => {
   };
   const initialize = (url, initialState) => {
     try {
-      const stateFromURl = getStateFromUrl(url, initialState);
-      if (!stateFromURl) {
+      const stateFromUrl = getStateFromUrl(url, initialState);
+      if (!stateFromUrl) {
         return initialState;
       }
-      const selected = getSelectedState(stateFromURl, url.pathname);
+      const selected = getSelectedState(stateFromUrl, url.pathname);
       const merged = (0, import_lodash_es.mergeWith)(
         {},
         initialState,
@@ -170,29 +520,7 @@ var queryStringImpl = (fn, options) => (set, get, api) => {
       get,
       api
     );
-    if (standalone) {
-      const registry = window.__ZUSTAND_QUERYSTRING_KEYS__;
-      const stateKeys = Object.keys(initialState).filter(
-        (k) => typeof initialState[k] !== "function"
-      );
-      const conflicts = [];
-      for (const key of stateKeys) {
-        if (registry.has(key)) {
-          const existing = registry.get(key);
-          const current = defaultedOptions.format;
-          if (existing !== current) {
-            conflicts.push(key);
-          }
-        } else {
-          registry.set(key, defaultedOptions.format);
-        }
-      }
-      if (conflicts.length > 0) {
-        throw new Error(
-          `[zustand-querystring] Standalone mode conflict: Multiple stores are using the following keys with different formats: ${conflicts.map((k) => `"${k}"`).join(", ")}. This will cause parsing errors. Please use unique state keys or the same format for all stores sharing keys.`
-        );
-      }
-    }
+    let previouslyManagedKeys = /* @__PURE__ */ new Set();
     const setQuery = () => {
       const url = new URL(window.location.href);
       const selectedState = getSelectedState(get(), url.pathname);
@@ -203,31 +531,55 @@ var queryStringImpl = (fn, options) => (set, get, api) => {
         defaultedOptions.syncUndefined
       );
       const previous = url.search;
+      let stateParams;
+      let managedKeys;
+      if (standalone) {
+        const allParams = format.stringifyStandalone(selectedState);
+        const currentKeys = new Set(Object.keys(allParams).map((k) => defaultedOptions.prefix + k));
+        managedKeys = /* @__PURE__ */ new Set([...Array.from(currentKeys), ...Array.from(previouslyManagedKeys)]);
+        previouslyManagedKeys = currentKeys;
+        const compactedParams = format.stringifyStandalone(newCompacted);
+        stateParams = {};
+        for (const [key, values] of Object.entries(compactedParams)) {
+          stateParams[defaultedOptions.prefix + key] = values;
+        }
+      } else {
+        const fullKey = defaultedOptions.prefix + defaultedOptions.key;
+        if (Object.keys(newCompacted).length > 0) {
+          stateParams = { [fullKey]: [format.stringify(newCompacted)] };
+        } else {
+          stateParams = {};
+        }
+        managedKeys = /* @__PURE__ */ new Set([fullKey]);
+      }
+      const valuesToWrite = /* @__PURE__ */ new Map();
+      const keyOrder = [];
+      for (const [key, values] of Object.entries(stateParams)) {
+        valuesToWrite.set(key, [...values]);
+        keyOrder.push(key);
+      }
       const params = url.search.slice(1).split("&").filter(Boolean);
-      const managedKeys = standalone ? new Set(Object.keys(selectedState).map(encodeURI)) : /* @__PURE__ */ new Set([defaultedOptions.key]);
-      const valuesToWrite = standalone ? new Map(
-        Object.entries(newCompacted).map(([k, v]) => [encodeURI(k), v])
-      ) : Object.keys(newCompacted).length ? /* @__PURE__ */ new Map([[defaultedOptions.key, newCompacted]]) : /* @__PURE__ */ new Map();
       const result = [];
-      params.forEach((p) => {
-        const key = p.split("=")[0];
+      params.forEach((param) => {
+        const eqIndex = param.indexOf("=");
+        if (eqIndex === -1) return;
+        const key = param.slice(0, eqIndex);
         if (!managedKeys.has(key)) {
-          result.push(p);
+          result.push(param);
           return;
         }
-        if (valuesToWrite.has(key)) {
-          const encoded = defaultedOptions.format.stringify(
-            valuesToWrite.get(key),
-            standalone
-          );
-          result.push(`${key}=${encoded}`);
-          valuesToWrite.delete(key);
+        const values = valuesToWrite.get(key);
+        if (values && values.length > 0) {
+          const value = values.shift();
+          result.push(`${key}=${value}`);
         }
       });
-      valuesToWrite.forEach((value, key) => {
-        const encoded = defaultedOptions.format.stringify(value, standalone);
-        result.push(`${key}=${encoded}`);
-      });
+      for (const key of keyOrder) {
+        const values = valuesToWrite.get(key);
+        if (values) {
+          values.forEach((v) => result.push(`${key}=${v}`));
+        }
+      }
       url.search = result.length ? "?" + result.join("&") : "";
       if (url.search !== previous) {
         history.replaceState(history.state, "", url);
@@ -251,6 +603,11 @@ var queryStringImpl = (fn, options) => (set, get, api) => {
       setQuery();
     };
     const initialized = initialize(new URL(window.location.href), initialState);
+    if (standalone) {
+      const initSelected = getSelectedState(initialized, new URL(window.location.href).pathname);
+      const initParams = format.stringifyStandalone(initSelected);
+      previouslyManagedKeys = new Set(Object.keys(initParams).map((k) => defaultedOptions.prefix + k));
+    }
     api.getInitialState = () => initialized;
     return initialized;
   } else if (defaultedOptions.url) {
@@ -264,22 +621,10 @@ var queryStringImpl = (fn, options) => (set, get, api) => {
   return fn(set, get, api);
 };
 var querystring = queryStringImpl;
-
-// src/utils.ts
-var createURL = ({
-  baseUrl,
-  key,
-  state
-}) => {
-  const url = new URL(baseUrl);
-  const stringified = stringify(state);
-  url.searchParams.set(key, stringified);
-  return url.href;
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createURL,
-  parse,
-  querystring,
-  stringify
+  querystring
 });
+/* v8 ignore next 4 -- @preserve: defensive - handles escape char at very end of source */
+/* v8 ignore next 3 -- @preserve: defensive - parseInt on digit string won't produce NaN */
+/* v8 ignore next 2 -- @preserve: defensive code - all valid types are handled above */