zustand-querystring 0.4.0 → 0.5.0

package/dist/index.mjs

@@ -1,15 +1,9 @@
-// src/middleware.ts
-import { isEqual, mergeWith } from "lodash-es";
-
-// src/parser.ts
-function stringify(input) {
-  return encodeURIComponent(JSON.stringify(input));
-}
-function parse(str) {
-  return JSON.parse(decodeURIComponent(str));
-}
+import {
+  marked
+} from "./chunk-TQQUWVLF.mjs";
 
 // src/middleware.ts
+import { isEqual, mergeWith } from "lodash-es";
 var compact = (newState, initialState, syncNull = false, syncUndefined = false) => {
   const output = {};
   const removed = [];
@@ -51,38 +45,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;
-  const getStateFromUrl = (url) => {
+  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 = new URLSearchParams(url.search);
-      const state = {};
-      params2.forEach((value, key) => {
-        state[key] = defaultedOptions.format.parse(value, true);
-      });
-      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);
-        return value ? defaultedOptions.format.parse(value, false) : null;
+      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 {
+          return format.parse(values[0], { initialState });
+        } catch {
+          return null;
+        }
+      }
+      return null;
     }
-    return null;
   };
   const getSelectedState = (state, pathname) => {
     if (defaultedOptions.select) {
@@ -94,18 +110,25 @@ var queryStringImpl = (fn, options) => (set, get, api) => {
   };
   const initialize = (url, initialState) => {
     try {
-      const stateFromURl = getStateFromUrl(url);
-      if (!stateFromURl) {
+      const stateFromUrl = getStateFromUrl(url, initialState);
+      if (!stateFromUrl) {
         return initialState;
       }
+      const selected = getSelectedState(stateFromUrl, url.pathname);
       const merged = mergeWith(
         {},
         initialState,
-        getSelectedState(stateFromURl, url.pathname)
+        selected,
+        (_objValue, srcValue) => {
+          if (Array.isArray(srcValue)) {
+            return srcValue;
+          }
+          return void 0;
+        }
       );
       return merged;
     } catch (error) {
-      console.error(error);
+      console.error("[initialize] error:", error);
       return initialState;
     }
   };
@@ -128,31 +151,53 @@ var queryStringImpl = (fn, options) => (set, get, api) => {
         defaultedOptions.syncUndefined
       );
       const previous = url.search;
+      let stateParams;
+      let managedKeys;
+      if (standalone) {
+        const allParams = format.stringifyStandalone(selectedState);
+        managedKeys = new Set(Object.keys(allParams).map((k) => defaultedOptions.prefix + k));
+        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);
@@ -189,21 +234,6 @@ 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;
-};
 export {
-  createURL,
-  parse,
-  querystring,
-  stringify
+  querystring
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zustand-querystring",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "license": "MIT",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -25,17 +25,33 @@
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
     },
-    "./format/readable": {
-      "types": "./dist/format/readable.d.ts",
-      "import": "./dist/format/readable.mjs",
-      "require": "./dist/format/readable.js"
+    "./format/marked": {
+      "types": "./dist/format/marked.d.ts",
+      "import": "./dist/format/marked.mjs",
+      "require": "./dist/format/marked.js"
+    },
+    "./format/plain": {
+      "types": "./dist/format/plain.d.ts",
+      "import": "./dist/format/plain.mjs",
+      "require": "./dist/format/plain.js"
+    },
+    "./format/json": {
+      "types": "./dist/format/json.d.ts",
+      "import": "./dist/format/json.mjs",
+      "require": "./dist/format/json.js"
     },
     "./package.json": "./package.json"
   },
   "typesVersions": {
     "*": {
-      "format/readable": [
-        "./dist/format/readable.d.ts"
+      "format/marked": [
+        "./dist/format/marked.d.ts"
+      ],
+      "format/plain": [
+        "./dist/format/plain.d.ts"
+      ],
+      "format/json": [
+        "./dist/format/json.d.ts"
       ]
     }
   },
@@ -48,7 +64,9 @@
     ],
     "entry": {
       "index": "src/index.ts",
-      "format/readable": "src/format/readable.ts"
+      "format/marked": "src/format/marked.ts",
+      "format/plain": "src/format/plain.ts",
+      "format/json": "src/format/json.ts"
     },
     "dts": true
   },
@@ -64,10 +82,18 @@
   },
   "devDependencies": {
     "@types/lodash-es": "^4.17.12",
+    "@types/react": "^19.0.10",
+    "@types/react-dom": "^19.0.4",
+    "@vitejs/plugin-react": "^4.3.4",
+    "@vitest/browser-playwright": "^4.0.14",
+    "@vitest/coverage-v8": "^4.0.14",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
     "rimraf": "^6.0.1",
     "tsup": "^8.4.0",
     "typescript": "^5.8.2",
     "vitest": "^4.0.12",
+    "vitest-browser-react": "^2.0.2",
     "zustand": "^5.0.3"
   }
 }

package/dist/format/readable.d.mts

@@ -1,14 +0,0 @@
-/**
- * URL-Safe Serialization
- *
- * Inspired by URLON (https://github.com/cerebral/urlon)
- * Copyright (c) 2021 Cerebral - MIT License
- */
-declare function stringify(value: unknown, standalone?: boolean): string;
-declare function parse<T = unknown>(input: string, standalone?: boolean): T;
-declare const readable: {
-    stringify: typeof stringify;
-    parse: typeof parse;
-};
-
-export { parse, readable, stringify };

package/dist/format/readable.d.ts

@@ -1,14 +0,0 @@
-/**
- * URL-Safe Serialization
- *
- * Inspired by URLON (https://github.com/cerebral/urlon)
- * Copyright (c) 2021 Cerebral - MIT License
- */
-declare function stringify(value: unknown, standalone?: boolean): string;
-declare function parse<T = unknown>(input: string, standalone?: boolean): T;
-declare const readable: {
-    stringify: typeof stringify;
-    parse: typeof parse;
-};
-
-export { parse, readable, stringify };

package/dist/format/readable.js

@@ -1,238 +0,0 @@
-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/format/readable.ts
-var readable_exports = {};
-__export(readable_exports, {
-  parse: () => parse,
-  readable: () => readable,
-  stringify: () => stringify
-});
-module.exports = __toCommonJS(readable_exports);
-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 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  parse,
-  readable,
-  stringify
-});