zustand-querystring 0.0.14 → 0.0.16

package/dist/chunk-QIA7KKX4.mjs

@@ -0,0 +1,187 @@
+import {
+  parse,
+  stringify
+} from "./chunk-QPGVZKLE.mjs";
+
+// src/middleware.ts
+import { mergeWith, isEqual, cloneDeep } from "lodash-es";
+var compact = (newState, initialState) => {
+  const output = {};
+  Object.keys(newState).forEach((key) => {
+    if (newState[key] !== null && newState[key] !== void 0 && typeof newState[key] !== "function" && !isEqual(newState[key], initialState[key])) {
+      if (typeof newState[key] === "object" && !Array.isArray(newState[key])) {
+        const value = compact(newState[key], initialState[key]);
+        if (value && Object.keys(value).length > 0) {
+          output[key] = value;
+        }
+      } else {
+        output[key] = newState[key];
+      }
+    }
+  });
+  return output;
+};
+var translateSelectionToState = (selection, state) => {
+  if (typeof state !== "object" || !state) {
+    return {};
+  }
+  return Object.keys(selection).reduce((acc, key) => {
+    if (!(key in state)) {
+      return acc;
+    }
+    const value = selection[key];
+    if (typeof value === "boolean") {
+      if (value) {
+        acc[key] = state[key];
+      }
+    } else {
+      acc[key] = translateSelectionToState(value, state[key]);
+    }
+    return acc;
+  }, {});
+};
+var escapeStringRegexp = (string) => {
+  if (typeof string !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
+};
+var queryStringImpl = (fn, options) => (set, get, api) => {
+  const defaultedOptions = {
+    key: "$",
+    ...options
+  };
+  const escapedKey = escapeStringRegexp(defaultedOptions.key);
+  const stateMatcher = new RegExp(`${escapedKey}=(.*);;|${escapedKey}=(.*)$`);
+  const splitMatcher = new RegExp(`${escapedKey}=.*;;|${escapedKey}=.*$`);
+  const parseQueryString = (querystring2) => {
+    var _a;
+    const match = querystring2.match(stateMatcher);
+    if (match) {
+      let m = (_a = match[1]) != null ? _a : match[2];
+      if (!m.startsWith("$")) {
+        m = "$" + m;
+      }
+      return parse(m);
+    }
+    return null;
+  };
+  const url = defaultedOptions.url;
+  const getSelectedState = (state, pathname) => {
+    if (defaultedOptions.select) {
+      const selection = defaultedOptions.select(pathname);
+      const selectedState = translateSelectionToState(selection, state);
+      return selectedState;
+    }
+    return state != null ? state : {};
+  };
+  const initialize = (url2, initialState) => {
+    try {
+      const queryString = url2.search.substring(1);
+      const pathname = url2.pathname;
+      if (!queryString) {
+        return initialState;
+      }
+      const parsed = parseQueryString(queryString);
+      if (!parsed) {
+        return initialState;
+      }
+      const merged = mergeWith(
+        cloneDeep(initialState),
+        getSelectedState(parsed, pathname)
+      );
+      set(merged, true);
+      return merged;
+    } catch (error) {
+      console.error(error);
+      return initialState;
+    }
+  };
+  if (typeof window !== "undefined") {
+    const initialState = cloneDeep(
+      fn(
+        (...args) => {
+          set(...args);
+          setQuery();
+        },
+        get,
+        api
+      )
+    );
+    const setQuery = () => {
+      const selectedState = getSelectedState(get(), location.pathname);
+      const currentQueryString = location.search;
+      const currentParsed = parseQueryString(currentQueryString);
+      const newMerged = {
+        ...currentParsed,
+        ...selectedState
+      };
+      const splitIgnored = currentQueryString.split(splitMatcher);
+      let ignored = "";
+      for (let str of splitIgnored) {
+        if (!str || str === "?" || str === "&") {
+          continue;
+        }
+        if (str.startsWith("&") || str.startsWith("?")) {
+          str = str.substring(1);
+        }
+        if (str.endsWith("&")) {
+          str = str.substring(0, str.length - 1);
+        }
+        ignored += (ignored ? "&" : "?") + str;
+      }
+      const newCompacted = compact(newMerged, initialState);
+      if (Object.keys(newCompacted).length) {
+        const stringified = stringify(newCompacted).substring(1);
+        const newQueryState = `${defaultedOptions.key}=${stringified};;`;
+        let newQueryString = "";
+        if (currentParsed) {
+          newQueryString = currentQueryString.replace(
+            splitMatcher,
+            newQueryState
+          );
+        } else if (ignored) {
+          newQueryString = ignored + "&" + newQueryState;
+        } else {
+          newQueryString = "?" + newQueryState;
+        }
+        history.replaceState(
+          history.state,
+          "",
+          location.pathname + newQueryString
+        );
+      } else {
+        history.replaceState(history.state, "", location.pathname + ignored);
+      }
+    };
+    if (!api.__ZUSTAND_QUERYSTRING_INIT__) {
+      api.__ZUSTAND_QUERYSTRING_INIT__ = true;
+      let previousPathname = "";
+      const cb = () => {
+        if (location.pathname !== previousPathname) {
+          previousPathname = location.pathname;
+          setQuery();
+        }
+        requestAnimationFrame(cb);
+      };
+      requestAnimationFrame(cb);
+    }
+    const originalSetState = api.setState;
+    api.setState = (...args) => {
+      originalSetState(...args);
+      setQuery();
+    };
+    return initialize(new URL(location.href), initialState);
+  } else if (url) {
+    return initialize(
+      new URL(decodeURIComponent(url), "http://localhost"),
+      fn(set, get, api)
+    );
+  }
+  return fn(set, get, api);
+};
+var querystring = queryStringImpl;
+
+export {
+  querystring
+};

package/dist/chunk-QPGVZKLE.mjs

@@ -0,0 +1,121 @@
+// src/parser.ts
+var keyStringifyRegexp = /([=:@$/])/g;
+var valueStringifyRegexp = /([&;/])/g;
+var keyParseRegexp = /[=:@$]/;
+var valueParseRegexp = /[&;]/;
+function encodeString(str, regexp) {
+  return encodeURI(str.replace(regexp, "/$1"));
+}
+function trim(res) {
+  return typeof res === "string" ? res.replace(/;+$/g, "") : res;
+}
+function stringify(input, recursive) {
+  if (!recursive) {
+    return trim(stringify(input, true));
+  }
+  if (typeof input === "function") {
+    return;
+  }
+  if (typeof input === "number" || input === true || input === false || input === null) {
+    return ":" + input;
+  }
+  const res = [];
+  if (Array.isArray(input)) {
+    for (const elem of input) {
+      typeof elem === "undefined" ? res.push(":null") : res.push(stringify(elem, true));
+    }
+    return "@" + res.join("&") + ";";
+  }
+  if (typeof input === "object") {
+    for (const [key, value] of Object.entries(input)) {
+      const stringifiedValue = stringify(value, true);
+      if (stringifiedValue) {
+        res.push(encodeString(key, keyStringifyRegexp) + stringifiedValue);
+      }
+    }
+    return "$" + res.join("&") + ";";
+  }
+  if (typeof input === "undefined") {
+    return;
+  }
+  return "=" + encodeString(input.toString(), valueStringifyRegexp);
+}
+function parse(str) {
+  let pos = 0;
+  str = decodeURI(str);
+  function readToken(regexp) {
+    let token = "";
+    for (; pos !== str.length; ++pos) {
+      if (str.charAt(pos) === "/") {
+        pos += 1;
+        if (pos === str.length) {
+          token += ";";
+          break;
+        }
+      } else if (str.charAt(pos).match(regexp)) {
+        break;
+      }
+      token += str.charAt(pos);
+    }
+    return token;
+  }
+  function parseToken() {
+    const type = str.charAt(pos++);
+    if (type === "=") {
+      return readToken(valueParseRegexp);
+    }
+    if (type === ":") {
+      const value = readToken(valueParseRegexp);
+      if (value === "true") {
+        return true;
+      }
+      if (value === "false") {
+        return false;
+      }
+      const parsedValue = parseFloat(value);
+      return isNaN(parsedValue) ? null : parsedValue;
+    }
+    if (type === "@") {
+      const res = [];
+      loop: {
+        if (pos >= str.length || str.charAt(pos) === ";") {
+          break loop;
+        }
+        while (1) {
+          res.push(parseToken());
+          if (pos >= str.length || str.charAt(pos) === ";") {
+            break loop;
+          }
+          pos += 1;
+        }
+      }
+      pos += 1;
+      return res;
+    }
+    if (type === "$") {
+      const res = {};
+      loop: {
+        if (pos >= str.length || str.charAt(pos) === ";") {
+          break loop;
+        }
+        while (1) {
+          var name = readToken(keyParseRegexp);
+          res[name] = parseToken();
+          if (pos >= str.length || str.charAt(pos) === ";") {
+            break loop;
+          }
+          pos += 1;
+        }
+      }
+      pos += 1;
+      return res;
+    }
+    throw new Error("Unexpected char " + type);
+  }
+  return parseToken();
+}
+
+export {
+  stringify,
+  parse
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { QueryStringOptions, querystring } from './middleware.js';
+import 'zustand/vanilla';

package/dist/index.js

@@ -0,0 +1,324 @@
+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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  querystring: () => querystring
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/parser.ts
+var keyStringifyRegexp = /([=:@$/])/g;
+var valueStringifyRegexp = /([&;/])/g;
+var keyParseRegexp = /[=:@$]/;
+var valueParseRegexp = /[&;]/;
+function encodeString(str, regexp) {
+  return encodeURI(str.replace(regexp, "/$1"));
+}
+function trim(res) {
+  return typeof res === "string" ? res.replace(/;+$/g, "") : res;
+}
+function stringify(input, recursive) {
+  if (!recursive) {
+    return trim(stringify(input, true));
+  }
+  if (typeof input === "function") {
+    return;
+  }
+  if (typeof input === "number" || input === true || input === false || input === null) {
+    return ":" + input;
+  }
+  const res = [];
+  if (Array.isArray(input)) {
+    for (const elem of input) {
+      typeof elem === "undefined" ? res.push(":null") : res.push(stringify(elem, true));
+    }
+    return "@" + res.join("&") + ";";
+  }
+  if (typeof input === "object") {
+    for (const [key, value] of Object.entries(input)) {
+      const stringifiedValue = stringify(value, true);
+      if (stringifiedValue) {
+        res.push(encodeString(key, keyStringifyRegexp) + stringifiedValue);
+      }
+    }
+    return "$" + res.join("&") + ";";
+  }
+  if (typeof input === "undefined") {
+    return;
+  }
+  return "=" + encodeString(input.toString(), valueStringifyRegexp);
+}
+function parse(str) {
+  let pos = 0;
+  str = decodeURI(str);
+  function readToken(regexp) {
+    let token = "";
+    for (; pos !== str.length; ++pos) {
+      if (str.charAt(pos) === "/") {
+        pos += 1;
+        if (pos === str.length) {
+          token += ";";
+          break;
+        }
+      } else if (str.charAt(pos).match(regexp)) {
+        break;
+      }
+      token += str.charAt(pos);
+    }
+    return token;
+  }
+  function parseToken() {
+    const type = str.charAt(pos++);
+    if (type === "=") {
+      return readToken(valueParseRegexp);
+    }
+    if (type === ":") {
+      const value = readToken(valueParseRegexp);
+      if (value === "true") {
+        return true;
+      }
+      if (value === "false") {
+        return false;
+      }
+      const parsedValue = parseFloat(value);
+      return isNaN(parsedValue) ? null : parsedValue;
+    }
+    if (type === "@") {
+      const res = [];
+      loop: {
+        if (pos >= str.length || str.charAt(pos) === ";") {
+          break loop;
+        }
+        while (1) {
+          res.push(parseToken());
+          if (pos >= str.length || str.charAt(pos) === ";") {
+            break loop;
+          }
+          pos += 1;
+        }
+      }
+      pos += 1;
+      return res;
+    }
+    if (type === "$") {
+      const res = {};
+      loop: {
+        if (pos >= str.length || str.charAt(pos) === ";") {
+          break loop;
+        }
+        while (1) {
+          var name = readToken(keyParseRegexp);
+          res[name] = parseToken();
+          if (pos >= str.length || str.charAt(pos) === ";") {
+            break loop;
+          }
+          pos += 1;
+        }
+      }
+      pos += 1;
+      return res;
+    }
+    throw new Error("Unexpected char " + type);
+  }
+  return parseToken();
+}
+
+// src/middleware.ts
+var import_lodash_es = require("lodash-es");
+var compact = (newState, initialState) => {
+  const output = {};
+  Object.keys(newState).forEach((key) => {
+    if (newState[key] !== null && newState[key] !== void 0 && typeof newState[key] !== "function" && !(0, import_lodash_es.isEqual)(newState[key], initialState[key])) {
+      if (typeof newState[key] === "object" && !Array.isArray(newState[key])) {
+        const value = compact(newState[key], initialState[key]);
+        if (value && Object.keys(value).length > 0) {
+          output[key] = value;
+        }
+      } else {
+        output[key] = newState[key];
+      }
+    }
+  });
+  return output;
+};
+var translateSelectionToState = (selection, state) => {
+  if (typeof state !== "object" || !state) {
+    return {};
+  }
+  return Object.keys(selection).reduce((acc, key) => {
+    if (!(key in state)) {
+      return acc;
+    }
+    const value = selection[key];
+    if (typeof value === "boolean") {
+      if (value) {
+        acc[key] = state[key];
+      }
+    } else {
+      acc[key] = translateSelectionToState(value, state[key]);
+    }
+    return acc;
+  }, {});
+};
+var escapeStringRegexp = (string) => {
+  if (typeof string !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
+};
+var queryStringImpl = (fn, options) => (set, get, api) => {
+  const defaultedOptions = {
+    key: "$",
+    ...options
+  };
+  const escapedKey = escapeStringRegexp(defaultedOptions.key);
+  const stateMatcher = new RegExp(`${escapedKey}=(.*);;|${escapedKey}=(.*)$`);
+  const splitMatcher = new RegExp(`${escapedKey}=.*;;|${escapedKey}=.*$`);
+  const parseQueryString = (querystring2) => {
+    var _a;
+    const match = querystring2.match(stateMatcher);
+    if (match) {
+      let m = (_a = match[1]) != null ? _a : match[2];
+      if (!m.startsWith("$")) {
+        m = "$" + m;
+      }
+      return parse(m);
+    }
+    return null;
+  };
+  const url = defaultedOptions.url;
+  const getSelectedState = (state, pathname) => {
+    if (defaultedOptions.select) {
+      const selection = defaultedOptions.select(pathname);
+      const selectedState = translateSelectionToState(selection, state);
+      return selectedState;
+    }
+    return state != null ? state : {};
+  };
+  const initialize = (url2, initialState) => {
+    try {
+      const queryString = url2.search.substring(1);
+      const pathname = url2.pathname;
+      if (!queryString) {
+        return initialState;
+      }
+      const parsed = parseQueryString(queryString);
+      if (!parsed) {
+        return initialState;
+      }
+      const merged = (0, import_lodash_es.mergeWith)(
+        (0, import_lodash_es.cloneDeep)(initialState),
+        getSelectedState(parsed, pathname)
+      );
+      set(merged, true);
+      return merged;
+    } catch (error) {
+      console.error(error);
+      return initialState;
+    }
+  };
+  if (typeof window !== "undefined") {
+    const initialState = (0, import_lodash_es.cloneDeep)(
+      fn(
+        (...args) => {
+          set(...args);
+          setQuery();
+        },
+        get,
+        api
+      )
+    );
+    const setQuery = () => {
+      const selectedState = getSelectedState(get(), location.pathname);
+      const currentQueryString = location.search;
+      const currentParsed = parseQueryString(currentQueryString);
+      const newMerged = {
+        ...currentParsed,
+        ...selectedState
+      };
+      const splitIgnored = currentQueryString.split(splitMatcher);
+      let ignored = "";
+      for (let str of splitIgnored) {
+        if (!str || str === "?" || str === "&") {
+          continue;
+        }
+        if (str.startsWith("&") || str.startsWith("?")) {
+          str = str.substring(1);
+        }
+        if (str.endsWith("&")) {
+          str = str.substring(0, str.length - 1);
+        }
+        ignored += (ignored ? "&" : "?") + str;
+      }
+      const newCompacted = compact(newMerged, initialState);
+      if (Object.keys(newCompacted).length) {
+        const stringified = stringify(newCompacted).substring(1);
+        const newQueryState = `${defaultedOptions.key}=${stringified};;`;
+        let newQueryString = "";
+        if (currentParsed) {
+          newQueryString = currentQueryString.replace(
+            splitMatcher,
+            newQueryState
+          );
+        } else if (ignored) {
+          newQueryString = ignored + "&" + newQueryState;
+        } else {
+          newQueryString = "?" + newQueryState;
+        }
+        history.replaceState(
+          history.state,
+          "",
+          location.pathname + newQueryString
+        );
+      } else {
+        history.replaceState(history.state, "", location.pathname + ignored);
+      }
+    };
+    if (!api.__ZUSTAND_QUERYSTRING_INIT__) {
+      api.__ZUSTAND_QUERYSTRING_INIT__ = true;
+      let previousPathname = "";
+      const cb = () => {
+        if (location.pathname !== previousPathname) {
+          previousPathname = location.pathname;
+          setQuery();
+        }
+        requestAnimationFrame(cb);
+      };
+      requestAnimationFrame(cb);
+    }
+    const originalSetState = api.setState;
+    api.setState = (...args) => {
+      originalSetState(...args);
+      setQuery();
+    };
+    return initialize(new URL(location.href), initialState);
+  } else if (url) {
+    return initialize(
+      new URL(decodeURIComponent(url), "http://localhost"),
+      fn(set, get, api)
+    );
+  }
+  return fn(set, get, api);
+};
+var querystring = queryStringImpl;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  querystring
+});

package/dist/index.mjs

@@ -0,0 +1,7 @@
+import {
+  querystring
+} from "./chunk-QIA7KKX4.mjs";
+import "./chunk-QPGVZKLE.mjs";
+export {
+  querystring
+};

package/{lib → dist}/middleware.d.ts

@@ -1,12 +1,14 @@
-import { StateCreator, StoreMutatorIdentifier } from 'zustand/vanilla';
+import { StoreMutatorIdentifier, StateCreator } from 'zustand/vanilla';
+
 type DeepSelect<T> = T extends object ? {
     [P in keyof T]?: DeepSelect<T[P]> | boolean;
 } : boolean;
-export interface QueryStringOptions<T> {
+interface QueryStringOptions<T> {
     url?: string;
     select?: (pathname: string) => DeepSelect<T>;
     key?: string;
 }
 type QueryString = <T, Mps extends [StoreMutatorIdentifier, unknown][] = [], Mcs extends [StoreMutatorIdentifier, unknown][] = []>(initializer: StateCreator<T, Mps, Mcs>, options?: QueryStringOptions<T>) => StateCreator<T, Mps, Mcs>;
-export declare const querystring: QueryString;
-export {};
+declare const querystring: QueryString;
+
+export { QueryStringOptions, querystring };