zustand-querystring 0.0.15 → 0.0.17

package/dist/chunk-4CDMBGCR.mjs

@@ -0,0 +1,183 @@
+import {
+  parse,
+  stringify
+} from "./chunk-77OZJNG4.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) {
+      return parse((_a = match[1]) != null ? _a : match[2]);
+    }
+    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);
+        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-77OZJNG4.mjs

@@ -0,0 +1,124 @@
+// 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, "").replace(/^\$/, "") : 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) {
+  if (!str.startsWith("$")) {
+    str = "$" + 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/chunk-STY4LBQG.mjs

@@ -0,0 +1,64 @@
+import {
+  parse,
+  stringify
+} from "./chunk-77OZJNG4.mjs";
+
+// src/utils.ts
+var escapeStringRegexp = (string) => {
+  if (typeof string !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
+};
+var parseQueryString = (key, querystring) => {
+  var _a;
+  const stateMatcher = new RegExp(`${key}=(.*);;|${key}=(.*)$`);
+  const match = querystring.match(stateMatcher);
+  if (match) {
+    return parse((_a = match[1]) != null ? _a : match[2]);
+  }
+  return null;
+};
+var createURL = ({
+  baseUrl,
+  key,
+  state
+}) => {
+  const escapedKey = escapeStringRegexp(key);
+  const stringified = stringify(state);
+  const newQueryState = `${key}=${stringified};;`;
+  const match = baseUrl.indexOf("?");
+  const currentQueryString = match >= 0 ? baseUrl.substring(match) : "";
+  const currentParsed = parseQueryString(escapedKey, currentQueryString);
+  const splitMatcher = new RegExp(`${escapedKey}=.*;;|${escapedKey}=.*$`);
+  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;
+  }
+  let newQueryString = "";
+  if (currentParsed) {
+    newQueryString = currentQueryString.replace(splitMatcher, newQueryState);
+  } else if (ignored) {
+    newQueryString = ignored + "&" + newQueryState;
+  } else {
+    newQueryString = "?" + newQueryState;
+  }
+  if (currentQueryString) {
+    return baseUrl.replace(currentQueryString, newQueryString);
+  }
+  return baseUrl + newQueryString;
+};
+
+export {
+  createURL
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { QueryStringOptions, querystring } from './middleware.js';
+export { parse, stringify } from './parser.js';
+export { createURL } from './utils.js';
+import 'zustand/vanilla';