zustand-querystring 0.4.1 → 0.5.0

package/dist/format/marked.js

@@ -0,0 +1,393 @@
+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/marked.ts
+var marked_exports = {};
+__export(marked_exports, {
+  createFormat: () => createFormat,
+  default: () => marked_default,
+  marked: () => marked,
+  parse: () => parse,
+  stringify: () => stringify
+});
+module.exports = __toCommonJS(marked_exports);
+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 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();
+var marked_default = marked;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFormat,
+  marked,
+  parse,
+  stringify
+});
+/* 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 */

package/dist/format/marked.mjs

@@ -0,0 +1,14 @@
+import {
+  createFormat,
+  marked,
+  marked_default,
+  parse,
+  stringify
+} from "../chunk-TQQUWVLF.mjs";
+export {
+  createFormat,
+  marked_default as default,
+  marked,
+  parse,
+  stringify
+};

package/dist/format/plain.d.mts

@@ -0,0 +1,49 @@
+import { QueryStringFormat } from '../index.mjs';
+import 'zustand/vanilla';
+
+/**
+ * Plain URL Query String Format
+ *
+ * A simple format for URL state serialization with optional configuration.
+ *
+ * Features:
+ * - Dot notation for nested objects: user.name=John
+ * - Repeated keys for arrays: tags=a&tags=b&tags=c
+ * - Proper escaping of special characters in both keys and values
+ * - Auto-parsing of numbers, booleans, and ISO dates
+ * - Type coercion from initialState when available
+ *
+ * Two modes:
+ * - Namespaced: entire state in one param (key: 'state')
+ * - Standalone: each field as separate param (key: false)
+ */
+
+interface PlainFormatOptions {
+    /** Separator between key=value entries in namespaced mode @default ',' */
+    entrySeparator?: string;
+    /** Separator for nested keys (e.g., user.name) @default '.' */
+    nestingSeparator?: string;
+    /** Array separator: 'repeat' for repeated keys, or string to join values @default 'repeat' */
+    arraySeparator?: 'repeat' | string;
+    /** Character used to escape special characters @default '_' */
+    escapeChar?: string;
+    /** String representation of null @default 'null' */
+    nullString?: string;
+    /** String representation of undefined @default 'undefined' */
+    undefinedString?: string;
+}
+/**
+ * Create a plain format with custom configuration.
+ */
+declare function createFormat(options?: PlainFormatOptions): QueryStringFormat;
+/**
+ * Default plain format with standard configuration.
+ *
+ * - Entry separator: `,`
+ * - Nesting separator: `.`
+ * - Array separator: `,` (comma-separated values)
+ * - Escape character: `_`
+ */
+declare const plain: QueryStringFormat;
+
+export { type PlainFormatOptions, createFormat, plain };

package/dist/format/plain.d.ts

@@ -0,0 +1,49 @@
+import { QueryStringFormat } from '../index.js';
+import 'zustand/vanilla';
+
+/**
+ * Plain URL Query String Format
+ *
+ * A simple format for URL state serialization with optional configuration.
+ *
+ * Features:
+ * - Dot notation for nested objects: user.name=John
+ * - Repeated keys for arrays: tags=a&tags=b&tags=c
+ * - Proper escaping of special characters in both keys and values
+ * - Auto-parsing of numbers, booleans, and ISO dates
+ * - Type coercion from initialState when available
+ *
+ * Two modes:
+ * - Namespaced: entire state in one param (key: 'state')
+ * - Standalone: each field as separate param (key: false)
+ */
+
+interface PlainFormatOptions {
+    /** Separator between key=value entries in namespaced mode @default ',' */
+    entrySeparator?: string;
+    /** Separator for nested keys (e.g., user.name) @default '.' */
+    nestingSeparator?: string;
+    /** Array separator: 'repeat' for repeated keys, or string to join values @default 'repeat' */
+    arraySeparator?: 'repeat' | string;
+    /** Character used to escape special characters @default '_' */
+    escapeChar?: string;
+    /** String representation of null @default 'null' */
+    nullString?: string;
+    /** String representation of undefined @default 'undefined' */
+    undefinedString?: string;
+}
+/**
+ * Create a plain format with custom configuration.
+ */
+declare function createFormat(options?: PlainFormatOptions): QueryStringFormat;
+/**
+ * Default plain format with standard configuration.
+ *
+ * - Entry separator: `,`
+ * - Nesting separator: `.`
+ * - Array separator: `,` (comma-separated values)
+ * - Escape character: `_`
+ */
+declare const plain: QueryStringFormat;
+
+export { type PlainFormatOptions, createFormat, plain };