@echojs-ecosystem/url-state 0.1.0

package/dist/index.js

@@ -0,0 +1,993 @@
+import { signal } from '@echojs-ecosystem/reactivity';
+
+// src/utils/equality.ts
+var defaultEquals = (a, b) => Object.is(a, b);
+
+// src/core/parser-meta.ts
+var hasDefault = (parser) => Object.prototype.hasOwnProperty.call(parser, "defaultValue");
+
+// src/core/default-visibility.ts
+var isVisibilityMode = (value) => value === "hide" || value === "show";
+var resolveDefaultVisibility = (options) => {
+  if (isVisibilityMode(options.defaultVisibility)) return options.defaultVisibility;
+  if (isVisibilityMode(options.defaultParamsBehavior)) return options.defaultParamsBehavior;
+  if (options.clearOnDefault === false) return "show";
+  if (options.clearOnDefault === true) return "hide";
+  return "hide";
+};
+var shouldHideDefaultInUrl = (value, parser, options) => {
+  if (!hasDefault(parser)) return false;
+  if (resolveDefaultVisibility(options) === "show") return false;
+  const parserEq = parser.eq;
+  const equals = options.equals === false ? null : parserEq ?? options.equals ?? defaultEquals;
+  return equals ? equals(value, parser.defaultValue) : false;
+};
+
+// src/core/options.ts
+var DEFAULT_QUERY_STATE_OPTIONS = {
+  history: "replace",
+  clearOnDefault: true,
+  shallow: true,
+  scroll: false,
+  limitUrlUpdates: false
+};
+var resolveSetOptions = (args) => {
+  const merged = {
+    ...DEFAULT_QUERY_STATE_OPTIONS,
+    ...args.createOptions ?? {},
+    ...args.parserOptions ?? {},
+    ...args.setOptions ?? {}
+  };
+  if (merged.defaultVisibility === "show") merged.clearOnDefault = false;
+  else if (merged.defaultVisibility === "hide") merged.clearOnDefault = true;
+  return merged;
+};
+
+// src/core/url.ts
+var normalizeSearch = (search) => {
+  if (!search) return "";
+  if (search === "?") return "";
+  return search.startsWith("?") ? search : `?${search}`;
+};
+var parseSearch = (search) => new URLSearchParams(normalizeSearch(search));
+var paramsToMap = (params) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const [key, value] of params.entries()) {
+    const arr = map.get(key);
+    if (arr) arr.push(value);
+    else map.set(key, [value]);
+  }
+  return map;
+};
+var stringifySearch = (params) => {
+  const map = paramsToMap(params);
+  const keys = [...map.keys()].sort();
+  const next = new URLSearchParams();
+  for (const key of keys) {
+    const values = map.get(key);
+    for (const value of values) next.append(key, value);
+  }
+  const str = next.toString();
+  return str ? `?${str}` : "";
+};
+var getSearchParam = (search, key) => {
+  const params = parseSearch(search);
+  const all = params.getAll(key);
+  if (all.length === 0) return null;
+  if (all.length === 1) return all[0];
+  return all;
+};
+var setSearchParam = (search, key, value) => {
+  const params = parseSearch(search);
+  params.delete(key);
+  if (value === null) return stringifySearch(params);
+  if (Array.isArray(value)) {
+    for (const item of value) params.append(key, item);
+  } else {
+    params.set(key, value);
+  }
+  return stringifySearch(params);
+};
+
+// src/core/update-queue.ts
+var queues = /* @__PURE__ */ new WeakMap();
+var getQueue = (adapter) => {
+  const existing = queues.get(adapter);
+  if (existing) return existing;
+  const next = { pending: null, microtaskQueued: false };
+  queues.set(adapter, next);
+  return next;
+};
+var mergePending = (prev, next) => {
+  if (!prev) return next;
+  const history = prev.options.history === "push" || next.options.history === "push" ? "push" : next.options.history ?? prev.options.history;
+  return {
+    ops: [...prev.ops, ...next.ops],
+    options: {
+      ...prev.options,
+      ...next.options,
+      history
+    }
+  };
+};
+var queueUrlUpdate = (adapter, ops, options) => {
+  const state = getQueue(adapter);
+  state.pending = mergePending(state.pending, { ops, options });
+  if (state.microtaskQueued) return;
+  state.microtaskQueued = true;
+  queueMicrotask(() => {
+    state.microtaskQueued = false;
+    const pending = state.pending;
+    state.pending = null;
+    if (!pending) return;
+    const doSet = () => {
+      let nextSearch = adapter.getSearch();
+      for (const op of pending.ops) {
+        nextSearch = setSearchParam(nextSearch, op.key, op.value);
+      }
+      adapter.setSearch(nextSearch, {
+        history: pending.options.history,
+        shallow: pending.options.shallow,
+        scroll: pending.options.scroll
+      });
+    };
+    const limiter = pending.options.limitUrlUpdates;
+    if (limiter) limiter.schedule(doSet);
+    else doSet();
+  });
+};
+
+// src/core/query-state.ts
+var parseRaw = (parser, raw) => {
+  const parsed = parser.parse(raw);
+  if (parsed === null && hasDefault(parser)) return parser.defaultValue;
+  return parsed;
+};
+var rawEquals = (a, b) => {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i += 1) if (a[i] !== b[i]) return false;
+    return true;
+  }
+  return false;
+};
+var readRawValue = (adapter, key) => {
+  return getSearchParam(adapter.getSearch(), key);
+};
+var createSyncedSignals = (args) => {
+  const getOptions = (setOptions) => resolveSetOptions({ createOptions: args.options, parserOptions: args.parser.options, setOptions });
+  const initialRaw = readRawValue(args.adapter, args.key);
+  const initialParsed = parseRaw(args.parser, initialRaw);
+  const $value = signal(initialParsed ?? (hasDefault(args.parser) ? args.parser.defaultValue : null));
+  const $rawValue = signal(initialRaw);
+  const syncFromAdapter = () => {
+    const adapterRaw = readRawValue(args.adapter, args.key);
+    if (!rawEquals(adapterRaw, $rawValue.peek())) $rawValue.set(adapterRaw);
+    const parsed = parseRaw(args.parser, adapterRaw);
+    const next = parsed ?? (hasDefault(args.parser) ? args.parser.defaultValue : null);
+    const equals = getOptions().equals === false ? null : getOptions().equals ?? defaultEquals;
+    if (!equals || !equals(next, $value.peek())) $value.set(next);
+  };
+  const unsubscribe = args.adapter.subscribe(syncFromAdapter);
+  const write = (next, setOptions) => {
+    const options = getOptions(setOptions);
+    const parsed = parseRaw(args.parser, next);
+    const nextValue = parsed ?? (hasDefault(args.parser) ? args.parser.defaultValue : null);
+    const equals = options.equals === false ? null : options.equals ?? defaultEquals;
+    if (!rawEquals(next, $rawValue.peek())) $rawValue.set(next);
+    if (!equals || !equals(nextValue, $value.peek())) $value.set(nextValue);
+    queueUrlUpdate(args.adapter, [{ key: args.key, value: next }], options);
+  };
+  return {
+    $rawValue,
+    $value,
+    getOptions,
+    write,
+    dispose: unsubscribe
+  };
+};
+
+// src/adapters/browser-adapter.ts
+var createBrowserUrlStateAdapter = () => {
+  if (typeof window === "undefined" || typeof window.history === "undefined" || typeof window.location === "undefined") {
+    throw new Error("@echojs-ecosystem/url-state: Browser adapter requires `window`");
+  }
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    for (const listener of listeners) listener();
+  };
+  window.addEventListener("popstate", notify);
+  return {
+    kind: "browser",
+    getSearch() {
+      return normalizeSearch(window.location.search);
+    },
+    setSearch(search, options) {
+      const normalized = normalizeSearch(search);
+      const pathname = window.location.pathname;
+      const hash = window.location.hash ?? "";
+      const nextUrl = `${pathname}${normalized}${hash}`;
+      const historyMode = options?.history ?? "replace";
+      if (historyMode === "push") window.history.pushState({}, "", nextUrl);
+      else window.history.replaceState({}, "", nextUrl);
+      notify();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0) ;
+      };
+    }
+  };
+};
+
+// src/adapters/memory-adapter.ts
+var createMemoryUrlStateAdapter = (initialSearch = "") => {
+  let search = normalizeSearch(initialSearch);
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    kind: "memory",
+    getSearch() {
+      return search;
+    },
+    setSearch(next) {
+      const normalized = normalizeSearch(next);
+      if (normalized === search) return;
+      search = normalized;
+      for (const listener of listeners) listener();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+};
+
+// src/adapters/adapter.ts
+var getDefaultUrlStateAdapter = () => {
+  if (typeof window !== "undefined" && typeof window.location !== "undefined") {
+    return createBrowserUrlStateAdapter();
+  }
+  return createMemoryUrlStateAdapter("");
+};
+
+// src/core/create-query-param.ts
+var createQueryParam = (key, parser, options = { defaultVisibility: "show" }) => {
+  const adapter = options.adapter ?? getDefaultUrlStateAdapter();
+  const state = createSyncedSignals({
+    adapter,
+    key,
+    parser,
+    options
+  });
+  const subscribe = (listener) => {
+    let prev = state.$value.peek();
+    return state.$value.subscribe(() => {
+      const next = state.$value.peek();
+      if (Object.is(next, prev)) return;
+      const p = prev;
+      prev = next;
+      listener(next, p);
+    });
+  };
+  const set = (value, setOptions) => {
+    const resolved = state.getOptions(setOptions);
+    if (value === null) {
+      state.write(null, resolved);
+      return;
+    }
+    if (shouldHideDefaultInUrl(value, parser, resolved)) {
+      state.write(null, resolved);
+      return;
+    }
+    const raw = parser.serialize(value);
+    state.write(raw, resolved);
+  };
+  const update = (updater, setOptions) => {
+    const current = state.$value.peek();
+    set(updater(current), setOptions);
+  };
+  const reset = (setOptions) => {
+    if (hasDefault(parser)) set(parser.defaultValue, setOptions);
+    else set(null, setOptions);
+  };
+  const clear = (setOptions) => set(null, setOptions);
+  return {
+    kind: "query-param",
+    key,
+    value: () => state.$value.value(),
+    set,
+    update,
+    reset,
+    clear,
+    $value: state.$value,
+    $rawValue: state.$rawValue,
+    subscribe
+  };
+};
+
+// src/adapters/router-adapter.ts
+var splitFullPath = (fullPath) => {
+  const hashIndex = fullPath.indexOf("#");
+  const beforeHash = hashIndex >= 0 ? fullPath.slice(0, hashIndex) : fullPath;
+  const hash = hashIndex >= 0 ? fullPath.slice(hashIndex) : "";
+  const qIndex = beforeHash.indexOf("?");
+  const pathname = qIndex >= 0 ? beforeHash.slice(0, qIndex) : beforeHash;
+  const search = qIndex >= 0 ? beforeHash.slice(qIndex) : "";
+  return { pathname: pathname || "/", search: normalizeSearch(search), hash };
+};
+var createRouterUrlStateAdapter = (router) => {
+  if (!router) return void 0;
+  return {
+    kind: "router",
+    getSearch() {
+      const { search } = splitFullPath(router.$fullPath.value());
+      return search;
+    },
+    setSearch(search, options) {
+      const { pathname, hash } = splitFullPath(router.$fullPath.value());
+      const normalized = normalizeSearch(search);
+      const next = `${pathname}${normalized}${hash}`;
+      const historyMode = options?.history ?? "replace";
+      if (historyMode === "replace" && router.replace) router.replace(next);
+      else router.go(next, { replace: historyMode === "replace" });
+    },
+    subscribe(listener) {
+      return router.$fullPath.subscribe(listener);
+    }
+  };
+};
+
+// src/adapters/router-registry.ts
+var activeRouter = null;
+var onRouterReady = [];
+var pendingSubscriptions = [];
+var registerUrlStateRouter = (router) => {
+  activeRouter = router;
+  const adapter = createRouterUrlStateAdapter(router);
+  for (const pending of pendingSubscriptions) {
+    pending.dispose = adapter.subscribe(pending.listener);
+    pending.listener();
+  }
+  for (const sync of onRouterReady) sync();
+  onRouterReady.length = 0;
+};
+var getUrlStateRouter = () => activeRouter;
+var onUrlStateRouterReady = (listener) => {
+  if (activeRouter) {
+    listener();
+    return () => {
+    };
+  }
+  onRouterReady.push(listener);
+  return () => {
+    const index = onRouterReady.indexOf(listener);
+    if (index >= 0) onRouterReady.splice(index, 1);
+  };
+};
+
+// src/adapters/auto-router-adapter.ts
+var createAutoRouterUrlStateAdapter = () => {
+  const fallback = getDefaultUrlStateAdapter();
+  const activeAdapter = () => {
+    const router = getUrlStateRouter();
+    if (router) return createRouterUrlStateAdapter(router);
+    return fallback;
+  };
+  return {
+    kind: "auto-router",
+    getSearch: () => activeAdapter().getSearch(),
+    setSearch: (search, options) => activeAdapter().setSearch(search, options),
+    subscribe(listener) {
+      let unsub = activeAdapter().subscribe(listener);
+      const offReady = onUrlStateRouterReady(() => {
+        unsub();
+        listener();
+        unsub = activeAdapter().subscribe(listener);
+      });
+      return () => {
+        offReady();
+        unsub();
+      };
+    }
+  };
+};
+
+// src/core/create-query-params.ts
+var getUrlKey = (schemaKey, options) => {
+  const override = options?.urlKeys?.[schemaKey];
+  return override ?? schemaKey;
+};
+var createQueryParams = (schema, options = {}) => {
+  const adapter = options.adapter ?? createAutoRouterUrlStateAdapter();
+  const usesAutoRouter = options.adapter === void 0;
+  const resolveOptions = (setOptions) => resolveSetOptions({ createOptions: options, parserOptions: void 0, setOptions });
+  const readSchema = () => {
+    const search = adapter.getSearch();
+    const out = {};
+    for (const key of Object.keys(schema)) {
+      const parser = schema[key];
+      const urlKey = getUrlKey(key, options);
+      const raw = getSearchParam(search, urlKey);
+      const parsed = parseRaw(parser, raw);
+      out[key] = parsed ?? (hasDefault(parser) ? parser.defaultValue : null);
+    }
+    return out;
+  };
+  const $value = signal(readSchema());
+  const syncFromAdapter = () => {
+    const next = readSchema();
+    const equals = resolveOptions().equals === false ? null : resolveOptions().equals ?? defaultEquals;
+    if (!equals || !equals(next, $value.peek())) $value.set(next);
+  };
+  adapter.subscribe(syncFromAdapter);
+  const emit = (next, prev, listener) => {
+    if (Object.is(next, prev)) return;
+    listener(next, prev);
+  };
+  const subscribe = (listener) => {
+    let prev = $value.peek();
+    return $value.subscribe(() => {
+      const next = $value.peek();
+      const p = prev;
+      prev = next;
+      emit(next, p, listener);
+    });
+  };
+  const writeOps = (ops, nextValue, setOptions) => {
+    const resolved = resolveOptions(setOptions);
+    const equals = resolved.equals === false ? null : resolved.equals ?? defaultEquals;
+    if (!equals || !equals(nextValue, $value.peek())) $value.set(nextValue);
+    queueUrlUpdate(adapter, ops, resolved);
+  };
+  const resetValue = () => {
+    const out = {};
+    for (const key of Object.keys(schema)) {
+      const parser = schema[key];
+      out[key] = hasDefault(parser) ? parser.defaultValue : null;
+    }
+    return out;
+  };
+  const buildUrlOpsFromSnapshot = (snapshot, resolved) => {
+    const ops = [];
+    for (const key of Object.keys(schema)) {
+      const parser = schema[key];
+      const fieldValue = snapshot[key];
+      const urlKey = getUrlKey(key, options);
+      if (fieldValue === null) {
+        ops.push({ key: urlKey, value: null });
+        continue;
+      }
+      if (shouldHideDefaultInUrl(fieldValue, parser, resolved)) {
+        ops.push({ key: urlKey, value: null });
+      } else {
+        ops.push({ key: urlKey, value: parser.serialize(fieldValue) });
+      }
+    }
+    return ops;
+  };
+  const syncDefaultsToUrl = (setOptions) => {
+    const resolved = resolveOptions(setOptions);
+    if (resolveDefaultVisibility(resolved) !== "show") return;
+    const snapshot = $value.peek();
+    writeOps(buildUrlOpsFromSnapshot(snapshot, resolved), snapshot, resolved);
+  };
+  if (usesAutoRouter) {
+    onUrlStateRouterReady(() => {
+      syncFromAdapter();
+      syncDefaultsToUrl();
+    });
+  } else {
+    queueMicrotask(() => syncDefaultsToUrl());
+  }
+  const set = (partialOrNull, setOptions) => {
+    const resolved = resolveOptions(setOptions);
+    if (partialOrNull === null) {
+      const ops2 = [];
+      for (const key of Object.keys(schema)) {
+        ops2.push({ key: getUrlKey(key, options), value: null });
+      }
+      writeOps(ops2, resetValue(), resolved);
+      return;
+    }
+    const prev = $value.peek();
+    const next = { ...prev };
+    const ops = [];
+    for (const key of Object.keys(partialOrNull)) {
+      const schemaKey = key;
+      const parser = schema[schemaKey];
+      const urlKey = getUrlKey(schemaKey, options);
+      const value = partialOrNull[schemaKey];
+      if (value === void 0) continue;
+      if (value === null) {
+        next[schemaKey] = hasDefault(parser) ? parser.defaultValue : null;
+        ops.push({ key: urlKey, value: null });
+        continue;
+      }
+      next[schemaKey] = value;
+      if (shouldHideDefaultInUrl(value, parser, resolved)) {
+        ops.push({ key: urlKey, value: null });
+      } else {
+        ops.push({ key: urlKey, value: parser.serialize(value) });
+      }
+    }
+    writeOps(ops, next, resolved);
+  };
+  const update = (updater, setOptions) => {
+    const current = $value.peek();
+    set(updater(current), setOptions);
+  };
+  const reset = (setOptions) => {
+    const resolved = resolveOptions(setOptions);
+    const ops = [];
+    const next = resetValue();
+    for (const key of Object.keys(schema)) {
+      const parser = schema[key];
+      const urlKey = getUrlKey(key, options);
+      const value = next[key];
+      if (value === null) {
+        ops.push({ key: urlKey, value: null });
+        continue;
+      }
+      if (shouldHideDefaultInUrl(value, parser, resolved)) ops.push({ key: urlKey, value: null });
+      else ops.push({ key: urlKey, value: parser.serialize(value) });
+    }
+    writeOps(ops, next, resolved);
+  };
+  const clear = (setOptions) => set(null, setOptions);
+  return {
+    kind: "query-params",
+    value: () => $value.value(),
+    set,
+    update,
+    reset,
+    clear,
+    $value,
+    subscribe
+  };
+};
+
+// src/adapters/bind-router-query-params.ts
+var attachRouterQueryParams = (router) => {
+  registerUrlStateRouter(router);
+  const bound = (schema, options) => createQueryParams(schema, {
+    ...options,
+    adapter: createRouterUrlStateAdapter(router)
+  });
+  return Object.assign(router, { createQueryParams: bound });
+};
+
+// src/core/parser.ts
+var createParser = (impl) => {
+  const base = {
+    parserMode: "single",
+    parse: impl.parse,
+    serialize: impl.serialize,
+    withDefault(defaultValue) {
+      return createParserWithDefault(base, defaultValue);
+    },
+    withOptions(options) {
+      return createParserWithOptions(base, options);
+    }
+  };
+  return base;
+};
+var createParserWithDefault = (parser, defaultValue) => {
+  const next = {
+    ...parser,
+    defaultValue,
+    withDefault(value) {
+      return createParserWithDefault(next, value);
+    },
+    withOptions(options) {
+      return createParserWithOptions(next, options);
+    }
+  };
+  return next;
+};
+var createParserWithOptions = (parser, options) => {
+  const next = {
+    ...parser,
+    options: { ...parser.options ?? {}, ...options },
+    withDefault(defaultValue) {
+      return createParserWithDefault(next, defaultValue);
+    },
+    withOptions(more) {
+      return createParserWithOptions(next, more);
+    }
+  };
+  return next;
+};
+
+// src/parsers/string.ts
+var first = (value) => {
+  if (value === null) return null;
+  if (Array.isArray(value)) return value[0] ?? null;
+  return value;
+};
+var parseAsString = createParser({
+  parse(value) {
+    const v = first(value);
+    if (v === null) return null;
+    return v;
+  },
+  serialize(value) {
+    return value;
+  }
+});
+
+// src/parsers/integer.ts
+var first2 = (value) => {
+  if (value === null) return null;
+  if (Array.isArray(value)) return value[0] ?? null;
+  return value;
+};
+var parseAsInteger = createParser({
+  parse(value) {
+    const v = first2(value);
+    if (v === null) return null;
+    if (!/^[+-]?\d+$/.test(v)) return null;
+    const n = Number.parseInt(v, 10);
+    return Number.isFinite(n) ? n : null;
+  },
+  serialize(value) {
+    if (!Number.isFinite(value)) return null;
+    return String(Math.trunc(value));
+  }
+});
+
+// src/parsers/float.ts
+var first3 = (value) => {
+  if (value === null) return null;
+  if (Array.isArray(value)) return value[0] ?? null;
+  return value;
+};
+var parseAsFloat = createParser({
+  parse(value) {
+    const v = first3(value);
+    if (v === null || v === "") return null;
+    const n = Number(v);
+    return Number.isFinite(n) ? n : null;
+  },
+  serialize(value) {
+    if (!Number.isFinite(value)) return null;
+    return String(value);
+  }
+});
+
+// src/parsers/boolean.ts
+var first4 = (value) => {
+  if (value === null) return null;
+  if (Array.isArray(value)) return value[0] ?? null;
+  return value;
+};
+var parseAsBoolean = createParser({
+  parse(value) {
+    const v = first4(value);
+    if (v === null) return null;
+    const lowered = v.toLowerCase();
+    if (lowered === "true") return true;
+    if (lowered === "false") return false;
+    if (lowered === "1") return true;
+    if (lowered === "0") return false;
+    return null;
+  },
+  serialize(value) {
+    return value ? "true" : "false";
+  }
+});
+
+// src/parsers/literal.ts
+var first5 = (value) => {
+  if (value === null) return null;
+  if (Array.isArray(value)) return value[0] ?? null;
+  return value;
+};
+var parseAsLiteral = (values) => {
+  const allowed = new Set(values.map((v) => String(v)));
+  return createParser({
+    parse(value) {
+      const v = first5(value);
+      if (v === null) return null;
+      if (!allowed.has(v)) return null;
+      return values.find((item) => String(item) === v) ?? null;
+    },
+    serialize(value) {
+      return String(value);
+    }
+  });
+};
+var parseAsStringLiteral = (values) => parseAsLiteral(values);
+var parseAsNumberLiteral = (values) => parseAsLiteral(values);
+
+// src/core/custom-multi-parser.ts
+var toQueryValues = (raw) => {
+  if (raw === null) return [];
+  if (typeof raw === "string") return [raw];
+  return [...raw];
+};
+var createMultiParserWithDefault = (parser, defaultValue) => {
+  const next = {
+    ...parser,
+    parserMode: "multi",
+    defaultValue,
+    withDefault(value) {
+      return createMultiParserWithDefault(parser, value);
+    },
+    withOptions(options) {
+      return createMultiParserWithOptions(parser, options);
+    }
+  };
+  return next;
+};
+var createMultiParserWithOptions = (parser, options) => ({
+  ...parser,
+  options: { ...parser.options ?? {}, ...options },
+  withDefault(defaultValue) {
+    return createMultiParserWithDefault(parser, defaultValue);
+  },
+  withOptions(more) {
+    return createMultiParserWithOptions(parser, more);
+  }
+});
+var createCustomMultiParser = (config) => {
+  const parser = {
+    parserMode: "multi",
+    parse(raw) {
+      return config.parse(toQueryValues(raw));
+    },
+    serialize(value) {
+      return [...config.serialize(value)];
+    },
+    withDefault(defaultValue) {
+      return createMultiParserWithDefault(parser, defaultValue);
+    },
+    withOptions(options) {
+      return createMultiParserWithOptions(parser, options);
+    }
+  };
+  if (config.eq) parser.eq = config.eq;
+  return parser;
+};
+var isMultiParser = (parser) => parser.parserMode === "multi";
+
+// src/parsers/array.ts
+var parseAsArrayOf = (item, separator) => createCustomMultiParser({
+  parse(value) {
+    let rawItems;
+    if (value.length === 0) return [];
+    if (separator && value.length === 1) {
+      rawItems = value[0].split(separator).filter(Boolean);
+    } else {
+      rawItems = value;
+    }
+    const out = [];
+    for (const raw of rawItems) {
+      const parsed = item.parse(raw);
+      if (parsed === null) return null;
+      out.push(parsed);
+    }
+    return out;
+  },
+  serialize(items) {
+    if (separator) {
+      const parts = [];
+      for (const entry of items) {
+        const serialized = item.serialize(entry);
+        if (serialized === null) return [];
+        if (Array.isArray(serialized)) parts.push(...serialized);
+        else parts.push(serialized);
+      }
+      return parts.length ? [parts.join(separator)] : [];
+    }
+    const out = [];
+    for (const entry of items) {
+      const serialized = item.serialize(entry);
+      if (serialized === null) return [];
+      if (Array.isArray(serialized)) out.push(...serialized);
+      else out.push(serialized);
+    }
+    return out;
+  },
+  eq(a, b) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i += 1) {
+      if (!Object.is(a[i], b[i])) return false;
+    }
+    return true;
+  }
+});
+
+// src/parsers/native-array.ts
+var serializeItem = (item, value) => {
+  const serialized = item.serialize(value);
+  if (serialized === null) return null;
+  if (Array.isArray(serialized)) return serialized[0] ?? null;
+  return serialized;
+};
+var parseAsNativeArrayOf = (item) => createCustomMultiParser({
+  parse(values) {
+    const out = [];
+    for (const raw of values) {
+      const parsed = item.parse(raw);
+      if (parsed === null) return null;
+      out.push(parsed);
+    }
+    return out;
+  },
+  serialize(items) {
+    const out = [];
+    for (const entry of items) {
+      const next = serializeItem(item, entry);
+      if (next === null) return [];
+      out.push(next);
+    }
+    return out;
+  },
+  eq(a, b) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i += 1) {
+      if (!Object.is(a[i], b[i])) return false;
+    }
+    return true;
+  }
+}).withDefault([]);
+
+// src/core/custom-parser.ts
+var createCustomParser = (config) => {
+  const parser = createParser({
+    parse: config.parse,
+    serialize: (value) => config.serialize(value)
+  });
+  if (config.eq) parser.eq = config.eq;
+  parser.parserMode = "single";
+  return parser;
+};
+
+// src/core/standard-schema.ts
+var validateJsonSchema = (schema, value) => {
+  if (!schema) return value;
+  if (typeof schema === "function") {
+    try {
+      return schema(value);
+    } catch {
+      return null;
+    }
+  }
+  const result = schema["~standard"].validate(value);
+  if (result && "value" in result && result.issues === void 0) {
+    return result.value;
+  }
+  return null;
+};
+
+// src/parsers/json.ts
+var first6 = (value) => {
+  if (value === null) return null;
+  if (Array.isArray(value)) return value[0] ?? null;
+  return value;
+};
+var parseAsJson = (schema) => createCustomParser({
+  parse(value) {
+    const raw = first6(value);
+    if (raw === null) return null;
+    try {
+      const data = JSON.parse(raw);
+      return validateJsonSchema(schema, data);
+    } catch {
+      return null;
+    }
+  },
+  serialize(value) {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return null;
+    }
+  }
+});
+
+// src/parsers/date.ts
+var first7 = (value) => {
+  if (value === null) return null;
+  if (Array.isArray(value)) return value[0] ?? null;
+  return value;
+};
+var parseAsIsoDate = createParser({
+  parse(value) {
+    const v = first7(value);
+    if (v === null) return null;
+    const date = new Date(v);
+    return Number.isNaN(date.getTime()) ? null : date;
+  },
+  serialize(value) {
+    const t = value.getTime();
+    if (Number.isNaN(t)) return null;
+    return value.toISOString();
+  }
+});
+
+// src/parsers/timestamp.ts
+var first8 = (value) => {
+  if (value === null) return null;
+  if (Array.isArray(value)) return value[0] ?? null;
+  return value;
+};
+var parseAsTimestamp = createParser({
+  parse(value) {
+    const v = first8(value);
+    if (v === null) return null;
+    if (!/^[+-]?\d+(\.\d+)?$/.test(v)) return null;
+    const n = Number(v);
+    return Number.isFinite(n) ? n : null;
+  },
+  serialize(value) {
+    if (!Number.isFinite(value)) return null;
+    return String(value);
+  }
+});
+
+// src/utils/throttle.ts
+var throttle = (ms) => {
+  let timer = null;
+  let pending = null;
+  const flush = () => {
+    if (!pending) return;
+    const fn = pending;
+    pending = null;
+    fn();
+  };
+  return {
+    kind: "throttle",
+    ms,
+    schedule(fn) {
+      pending = fn;
+      if (timer) return;
+      timer = setTimeout(() => {
+        timer = null;
+        flush();
+      }, ms);
+    },
+    cancel() {
+      if (timer) clearTimeout(timer);
+      timer = null;
+      pending = null;
+    }
+  };
+};
+
+// src/utils/debounce.ts
+var debounce = (ms) => {
+  let timer = null;
+  let pending = null;
+  const flush = () => {
+    if (!pending) return;
+    const fn = pending;
+    pending = null;
+    fn();
+  };
+  return {
+    kind: "debounce",
+    ms,
+    schedule(fn) {
+      pending = fn;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        timer = null;
+        flush();
+      }, ms);
+    },
+    cancel() {
+      if (timer) clearTimeout(timer);
+      timer = null;
+      pending = null;
+    }
+  };
+};
+
+export { attachRouterQueryParams, createBrowserUrlStateAdapter, createCustomMultiParser, createCustomParser, createMemoryUrlStateAdapter, createQueryParam, createQueryParams, createRouterUrlStateAdapter, debounce, getUrlStateRouter, isMultiParser, parseAsArrayOf, parseAsBoolean, parseAsFloat, parseAsInteger, parseAsIsoDate, parseAsJson, parseAsLiteral, parseAsNativeArrayOf, parseAsNumberLiteral, parseAsString, parseAsStringLiteral, parseAsTimestamp, throttle };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map