vanilla-jui 1.7.0 → 1.7.2

package/src/primitives/drop.ts

@@ -8,7 +8,7 @@ import {
 } from '../utilities/dom.ts';
 import { createEventManager } from '../utilities/events.ts';
 import { randomId } from '../utilities/id.ts';
-import { type ResolveSchema, resolveProps } from '../utilities/types.ts';
+import { type ConfigSchema, resolveConfig } from '../utilities/config.ts';
 import { createLoading } from './loading.ts';
 
 type DropMode = 'hover' | 'click';
@@ -144,11 +144,8 @@ const DROP_PROPS_SCHEMA = {
   },
   className: {
     default: DEFAULT_CLASS_NAMES,
-    type: 'object',
-    normalize: (value: unknown) => ({
-      ...DEFAULT_CLASS_NAMES,
-      ...(value && typeof value === 'object' ? value : {}),
-    }),
+    type: 'plainObject',
+    merge: 'shallow',
   },
   id: {
     default: null,
@@ -166,10 +163,10 @@ const DROP_PROPS_SCHEMA = {
   hoverIntent: { default: true, type: 'boolean' },
   onShown: { default: null, types: ['function', 'null'] },
   onHidden: { default: null, types: ['function', 'null'] },
-} satisfies ResolveSchema<DropProps>;
+} satisfies ConfigSchema<DropProps>;
 
 function normalizeProps(input: DropProps): ResolvedDropProps {
-  const props = resolveProps(input, DROP_PROPS_SCHEMA, 'Drop');
+  const props = resolveConfig(input, DROP_PROPS_SCHEMA, 'Drop');
   return {
     name: props.name as string | null,
     mode: props.mode as DropMode,

package/src/primitives/parabola.ts

@@ -3,7 +3,7 @@ import { insert, jsx } from 'vanilla-signal';
 import { type DOMReference, resolveElement } from '../utilities/dom.ts';
 import { randomId } from '../utilities/id.ts';
 import { timer } from '../utilities/timer.ts';
-import { type ResolveSchema, resolveProps } from '../utilities/types.ts';
+import { type ConfigSchema, resolveConfig } from '../utilities/config.ts';
 
 type ParabolaDirection =
   | 'center'
@@ -81,10 +81,7 @@ const PARABOLA_PROPS_SCHEMA = {
   ball: {
     default: DEFAULT_BALL,
     type: 'plainObject',
-    normalize: (value: unknown) => ({
-      ...DEFAULT_BALL,
-      ...(value && typeof value === 'object' ? value : {}),
-    }),
+    merge: 'shallow',
     shape: {
       color: 'string',
       size: 'string',
@@ -92,11 +89,8 @@ const PARABOLA_PROPS_SCHEMA = {
   },
   className: {
     default: DEFAULT_CLASS_NAMES,
-    type: 'object',
-    normalize: (value: unknown) => ({
-      ...DEFAULT_CLASS_NAMES,
-      ...(value && typeof value === 'object' ? value : {}),
-    }),
+    type: 'plainObject',
+    merge: 'shallow',
   },
   from: { default: null, ...ELEMENT_REF_RULE },
   to: { default: null, ...ELEMENT_REF_RULE },
@@ -108,10 +102,10 @@ const PARABOLA_PROPS_SCHEMA = {
   showDelay: { default: 0, type: 'number' },
   onShow: { default: null, types: ['function', 'null'] },
   onHidden: { default: null, types: ['function', 'null'] },
-} satisfies ResolveSchema<ParabolaProps>;
+} satisfies ConfigSchema<ParabolaProps>;
 
 function normalizeProps(input: ParabolaProps): ResolvedParabolaProps {
-  const props = resolveProps(input, PARABOLA_PROPS_SCHEMA, 'Parabola.props');
+  const props = resolveConfig(input, PARABOLA_PROPS_SCHEMA, 'Parabola.props');
   return {
     ball: props.ball as ParabolaBallProps,
     className: props.className as ParabolaClassNames,

package/src/primitives/popup.ts

@@ -1,7 +1,7 @@
 import { type ElementProps, jsx } from 'vanilla-signal';
 
 import { asRenderable, type RenderableContent } from '../utilities/dom.ts';
-import { type ResolveSchema, resolveProps } from '../utilities/types.ts';
+import { type ConfigSchema, resolveConfig } from '../utilities/config.ts';
 
 export interface PopupProps extends Record<string, unknown> {
   className?: string;
@@ -28,10 +28,10 @@ const POPUP_PROPS_SCHEMA = {
     default: '',
     type: 'renderable',
   },
-} satisfies ResolveSchema<PopupProps>;
+} satisfies ConfigSchema<PopupProps>;
 
 function normalizeProps(input: PopupProps): ResolvedPopupProps {
-  const props = resolveProps(input, POPUP_PROPS_SCHEMA, 'Popup');
+  const props = resolveConfig(input, POPUP_PROPS_SCHEMA, 'Popup');
 
   return {
     className: props.className as string,

package/src/primitives/sticky.ts

@@ -1,7 +1,7 @@
 import { createDeepStore, flushSync } from 'vanilla-signal';
 import { randomId } from '../utilities/id.ts';
 import { type DOMReference, all, requireContainer } from '../utilities/dom.ts';
-import { type ResolveSchema, resolveProps } from '../utilities/types.ts';
+import { type ConfigSchema, resolveConfig } from '../utilities/config.ts';
 
 type StickyOverflow = 'destroy' | 'ignore';
 
@@ -91,10 +91,10 @@ const STICKY_PROPS_SCHEMA = {
   },
   reactive: { default: false, type: 'boolean' },
   onReBuild: { default: null, types: ['function', 'null'] },
-} satisfies ResolveSchema<StickyProps>;
+} satisfies ConfigSchema<StickyProps>;
 
 function normalizeProps(input: StickyProps): ResolvedStickyProps {
-  const props = resolveProps(input, STICKY_PROPS_SCHEMA, 'Sticky.props');
+  const props = resolveConfig(input, STICKY_PROPS_SCHEMA, 'Sticky.props');
   return {
     target: props.target as DOMReference,
     parent: props.parent as DOMReference,

package/src/primitives/theme.ts

@@ -11,6 +11,8 @@ import { translate } from '../utilities/locale.ts';
 import { all, joinClasses } from '../utilities/dom.ts';
 import { createEventManager } from '../utilities/events.ts';
 import { isPlainObject } from '../utilities/object.ts';
+import { type ConfigSchema, resolveConfig } from '../utilities/config.ts';
+import { mergeShallowConfig } from '../utilities/merge.ts';
 
 export type ThemeConfigKey = 'mode' | 'theme' | 'radius' | 'shadow' | 'font';
 
@@ -101,16 +103,26 @@ const THEME_CLASS_PREFIX: Record<Exclude<ThemeConfigKey, 'mode'>, string> = {
   font: 'j-font-',
 };
 
-function mergeClassNames(className?: ThemeClassNameConfig): ThemeClassNames {
-  return { ...DEFAULT_CLASS_NAMES, ...className };
-}
+const THEME_OPTIONS_SCHEMA = {
+  mode: { default: DEFAULT_OPTIONS.mode, type: 'string' },
+  theme: { default: DEFAULT_OPTIONS.theme, type: 'string' },
+  radius: { default: DEFAULT_OPTIONS.radius, type: 'string' },
+  shadow: { default: DEFAULT_OPTIONS.shadow, type: 'string' },
+  font: { default: DEFAULT_OPTIONS.font, type: 'string' },
+  key: { default: DEFAULT_OPTIONS.key, type: 'string' },
+  className: {
+    default: DEFAULT_CLASS_NAMES,
+    type: 'plainObject',
+    merge: 'shallow',
+  },
+} satisfies ConfigSchema<ThemeOptions>;
 
 function normalizeOptions(options: ThemeOptions = {}): ThemeResolvedOptions {
-  return {
-    ...DEFAULT_OPTIONS,
-    ...options,
-    className: mergeClassNames(options.className),
-  };
+  return resolveConfig(
+    options,
+    THEME_OPTIONS_SCHEMA,
+    'Theme.options'
+  ) as unknown as ThemeResolvedOptions;
 }
 
 function isThemeConfigKey(value: string | undefined): value is ThemeConfigKey {
@@ -340,14 +352,17 @@ export function createTheme(options: ThemeOptions = {}): ThemeInstance {
     return panel;
   };
   const setConfig = (newConfig: ThemeOptions): void => {
+    const config = normalizeOptions({
+      ...props,
+      ...newConfig,
+      className: mergeShallowConfig(
+        props.className,
+        newConfig.className ?? {}
+      ) as ThemeClassNames,
+    });
     runtime.configVersion += 1;
     flushSync(() => {
-      Object.assign(props, newConfig, {
-        className: mergeClassNames({
-          ...props.className,
-          ...newConfig.className,
-        }),
-      });
+      Object.assign(props, config);
     });
     saveConfig();
   };

package/src/primitives/toast.ts

@@ -12,6 +12,7 @@ import { createLoading } from '../primitives/loading.ts';
 import { joinClasses, q } from '../utilities/dom.ts';
 import { listen } from '../utilities/events.ts';
 import { randomId } from '../utilities/id.ts';
+import { mergeShallowConfig } from '../utilities/merge.ts';
 import { timer } from '../utilities/timer.ts';
 import { validateParam } from '../utilities/types.ts';
 
@@ -98,14 +99,6 @@ const operations = new Map<HTMLElement, number>();
 const singletonToasts = new Map<'show' | 'confirm', HTMLElement>();
 let classNames = DEFAULT_CLASS_NAMES;
 
-function mergeClassNames(value?: ToastClassNameConfig): ToastClassNames {
-  return { ...DEFAULT_CLASS_NAMES, ...value };
-}
-
-function resolveClassNames(options?: ToastClassNameOptions): ToastClassNames {
-  return mergeClassNames({ ...classNames, ...options?.className });
-}
-
 function addToastDisposer(element: HTMLElement, dispose: () => void): void {
   const current = disposers.get(element);
   disposers.set(element, () => {
@@ -378,7 +371,10 @@ function show(message = '', options: ToastOptions = {}): HTMLElement {
   validateParam('duration', duration, TOAST_DURATION_RULE, 'Toast.show');
   validateParam('theme', theme, TOAST_THEME_RULE, 'Toast.show');
 
-  const names = resolveClassNames(options);
+  const names = mergeShallowConfig(
+    classNames,
+    options.className ?? {}
+  ) as ToastClassNames;
   const id = randomId();
   const iconElement = jsx('span', {
     className: names.icon,
@@ -426,7 +422,10 @@ function lite(
   validateParam('message', message, 'string', 'Toast.lite');
   validateParam('duration', duration, LITE_DURATION_RULE, 'Toast.lite');
 
-  const names = mergeClassNames({ ...classNames, ...className });
+  const names = mergeShallowConfig(
+    classNames,
+    className ?? {}
+  ) as ToastClassNames;
   const previous = q<HTMLElement>('[data-toast-lite]');
   if (previous) {
     cancelToastTimers(previous.dataset.toast || '');
@@ -457,7 +456,10 @@ function confirm(message = '', props: ToastConfirmProps = {}): HTMLElement {
   const theme = props.theme || 'info';
   validateParam('once', once, 'boolean', 'Toast.confirm');
   validateParam('theme', theme, TOAST_THEME_RULE, 'Toast.confirm');
-  const names = resolveClassNames(props);
+  const names = mergeShallowConfig(
+    classNames,
+    props.className ?? {}
+  ) as ToastClassNames;
   const id = randomId();
   const element = jsx('div', {
     className: joinClasses(names.confirm, names[theme]),
@@ -526,7 +528,10 @@ export const Toast = {
   timers,
   disposers,
   configure(options: ToastClassNameOptions = {}): ToastClassNameOptions {
-    classNames = mergeClassNames(options.className);
+    classNames = mergeShallowConfig(
+      DEFAULT_CLASS_NAMES,
+      options.className ?? {}
+    ) as ToastClassNames;
     return { className: classNames };
   },
   show,

package/src/primitives/tooltip.ts

@@ -1,7 +1,7 @@
 import { jsx } from 'vanilla-signal';
 
 import { type DOMReference, joinClasses } from '../utilities/dom.ts';
-import { type ResolveSchema, resolveProps } from '../utilities/types.ts';
+import { type ConfigSchema, resolveConfig } from '../utilities/config.ts';
 import { createDrop } from './drop.ts';
 
 type DropInstance = ReturnType<typeof createDrop>;
@@ -102,20 +102,6 @@ const DEFAULT_CLASS_NAMES: TooltipClassNames = {
   },
 };
 
-function normalizeClassNames(value: unknown): TooltipClassNames {
-  const input = value && typeof value === 'object' ? value : {};
-  const ui =
-    'ui' in input && input.ui && typeof input.ui === 'object' ? input.ui : {};
-  return {
-    ...DEFAULT_CLASS_NAMES,
-    ...input,
-    ui: {
-      ...DEFAULT_CLASS_NAMES.ui,
-      ...ui,
-    },
-  };
-}
-
 const TOOLTIP_OPTIONS_SCHEMA = {
   name: { default: null, types: ['string', 'null'] },
   mode: { default: 'hover', type: 'string', enum: ['hover', 'click'] },
@@ -155,18 +141,18 @@ const TOOLTIP_OPTIONS_SCHEMA = {
   },
   className: {
     default: DEFAULT_CLASS_NAMES,
-    type: 'object',
-    normalize: normalizeClassNames,
+    type: 'plainObject',
+    merge: 'deep',
   },
   id: { default: null, types: ['string', 'null'] },
   delay: { default: 100, types: ['number', 'object'] },
   hoverIntent: { default: true, type: 'boolean' },
   onShown: { default: null, types: ['function', 'null'] },
   onHidden: { default: null, types: ['function', 'null'] },
-} satisfies ResolveSchema<TooltipProps>;
+} satisfies ConfigSchema<TooltipProps>;
 
 function normalizeProps(input: TooltipProps): ResolvedTooltipProps {
-  const props = resolveProps(input, TOOLTIP_OPTIONS_SCHEMA, 'Tooltip.props');
+  const props = resolveConfig(input, TOOLTIP_OPTIONS_SCHEMA, 'Tooltip.props');
   return {
     name: props.name as string | null,
     mode: props.mode as DropMode,

package/src/utilities/config.ts

@@ -0,0 +1,158 @@
+import { type ParamRule, type ParamRuleInput, validateParam } from './types.ts';
+import {
+  type MergeStrategy,
+  cloneConfigValue,
+  mergeConfigValue,
+} from './merge.ts';
+import { isPlainObject } from './object.ts';
+
+type LooseRecord = Record<string, unknown>;
+type ConfigTypeRule = string | readonly string[];
+
+export interface ConfigNormalizeContext<
+  TInput extends LooseRecord = LooseRecord,
+> {
+  key: string;
+  path: string;
+  input: TInput;
+  options: LooseRecord;
+  schema: ConfigSchema<TInput>;
+}
+
+export interface ConfigRule<
+  TInput extends LooseRecord = LooseRecord,
+> extends Omit<ParamRule<TInput>, 'normalize' | 'shape'> {
+  defaultFactory?: () => unknown;
+  merge?: MergeStrategy;
+  schema?: ConfigSchema;
+  normalize?: (
+    value: unknown,
+    context: ConfigNormalizeContext<TInput>
+  ) => unknown;
+}
+
+export type ConfigRuleInput<TInput extends LooseRecord = LooseRecord> =
+  | ConfigTypeRule
+  | ConfigRule<TInput>;
+
+export type ConfigSchema<TInput extends LooseRecord = LooseRecord> = Record<
+  string,
+  ConfigRuleInput<TInput>
+>;
+
+export type ResolvedConfig<TSchema extends object> = LooseRecord & {
+  [Key in keyof TSchema]: unknown;
+};
+
+function normalizeConfigRule<TInput extends LooseRecord>(
+  rule: ConfigRuleInput<TInput> = {}
+): ConfigRule<TInput> {
+  if (typeof rule === 'string' || Array.isArray(rule)) return { type: rule };
+  if (!rule || typeof rule !== 'object') return {};
+  return rule as ConfigRule<TInput>;
+}
+
+function resolveConfigDefault<TInput extends LooseRecord>(
+  rule: ConfigRule<TInput>
+): unknown {
+  if (typeof rule.defaultFactory === 'function') {
+    return cloneConfigValue(rule.defaultFactory());
+  }
+  if (Object.hasOwn(rule, 'default')) {
+    return cloneConfigValue(rule.default);
+  }
+  return undefined;
+}
+
+function isInputMissing(source: LooseRecord, key: string): boolean {
+  return !Object.hasOwn(source, key) || source[key] === undefined;
+}
+
+function resolveConfigValue<TInput extends LooseRecord>(
+  key: string,
+  rule: ConfigRule<TInput>,
+  source: TInput,
+  namespace: string
+): unknown {
+  const path = namespace ? `${namespace}.${key}` : key;
+  const defaultValue = resolveConfigDefault(rule);
+  const value = isInputMissing(source, key)
+    ? defaultValue
+    : mergeConfigValue(defaultValue, source[key], rule.merge, { key, path });
+
+  return rule.schema && (value === undefined || isPlainObject(value))
+    ? resolveConfig(value as LooseRecord | undefined, rule.schema, path)
+    : value;
+}
+
+function validateConfigValue<TInput extends LooseRecord>(
+  key: string,
+  value: unknown,
+  rule: ConfigRule<TInput>,
+  namespace: string
+): void {
+  const validationRule: ParamRuleInput<TInput> = rule as ParamRule<TInput>;
+  validateParam(key, value, validationRule, namespace);
+
+  if (!rule.schema || !isPlainObject(value)) return;
+
+  const childNamespace = namespace ? `${namespace}.${key}` : key;
+  const valueRecord = value as LooseRecord;
+  for (const [childKey, childRule] of Object.entries(rule.schema)) {
+    validateConfigValue(
+      childKey,
+      valueRecord[childKey],
+      normalizeConfigRule(childRule),
+      childNamespace
+    );
+  }
+}
+
+export function resolveConfig<
+  TInput extends LooseRecord,
+  TSchema extends ConfigSchema<TInput>,
+>(
+  input: TInput | null | undefined = {} as TInput,
+  schema: TSchema = {} as TSchema,
+  namespace = 'Config'
+): ResolvedConfig<TSchema> {
+  const source = input == null ? {} : input;
+  if (typeof source !== 'object' || Array.isArray(source)) {
+    throw new Error(`${namespace} expects object.`);
+  }
+
+  const sourceRecord = source as TInput;
+  const resolved: LooseRecord = {};
+  const entries = Object.entries(schema || {}) as Array<
+    [string, ConfigRuleInput<TInput>]
+  >;
+
+  for (const [key, rawRule] of entries) {
+    const rule = normalizeConfigRule<TInput>(rawRule);
+    resolved[key] = resolveConfigValue(key, rule, sourceRecord, namespace);
+  }
+
+  for (const [key, rawRule] of entries) {
+    const rule = normalizeConfigRule<TInput>(rawRule);
+    if (typeof rule.normalize === 'function') {
+      resolved[key] = rule.normalize(resolved[key], {
+        key,
+        path: namespace ? `${namespace}.${key}` : key,
+        input: sourceRecord,
+        options: resolved,
+        schema,
+      });
+    }
+  }
+
+  for (const [key, rule] of entries) {
+    validateConfigValue(
+      key,
+      resolved[key],
+      normalizeConfigRule<TInput>(rule),
+      namespace
+    );
+  }
+
+  return resolved as ResolvedConfig<TSchema>;
+}

package/src/utilities/id.ts

@@ -73,6 +73,125 @@ type QueryParamValue =
  */
 type QueryParams = Record<string, QueryParamValue>;
 
+// const SHA256_K = new Uint32Array([
+//   0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
+//   0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+//   0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+//   0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+//   0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+//   0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+//   0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+//   0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+//   0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+//   0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+//   0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+// ]);
+
+// const SHA256_INITIAL = new Uint32Array([
+//   0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
+//   0x1f83d9ab, 0x5be0cd19,
+// ]);
+
+// function rotateRight(value: number, bits: number): number {
+//   return (value >>> bits) | (value << (32 - bits));
+// }
+
+// function sha256Fallback(input: Uint8Array): Uint8Array {
+//   const message = new Uint8Array(Math.ceil((input.length + 9) / 64) * 64);
+//   message.set(input);
+//   message[input.length] = 0x80;
+
+//   const bitLength = BigInt(input.length) * 8n;
+//   for (let i = 0; i < 8; i += 1) {
+//     message[message.length - 1 - i] = Number(
+//       (bitLength >> BigInt(i * 8)) & 0xffn
+//     );
+//   }
+
+//   const hash = new Uint32Array(SHA256_INITIAL);
+//   const words = new Uint32Array(64);
+
+//   for (let offset = 0; offset < message.length; offset += 64) {
+//     for (let i = 0; i < 16; i += 1) {
+//       const index = offset + i * 4;
+//       words[i] =
+//         ((message[index] << 24) |
+//           (message[index + 1] << 16) |
+//           (message[index + 2] << 8) |
+//           message[index + 3]) >>>
+//         0;
+//     }
+
+//     for (let i = 16; i < 64; i += 1) {
+//       const s0 =
+//         rotateRight(words[i - 15], 7) ^
+//         rotateRight(words[i - 15], 18) ^
+//         (words[i - 15] >>> 3);
+//       const s1 =
+//         rotateRight(words[i - 2], 17) ^
+//         rotateRight(words[i - 2], 19) ^
+//         (words[i - 2] >>> 10);
+//       words[i] = (words[i - 16] + s0 + words[i - 7] + s1) >>> 0;
+//     }
+
+//     let a = hash[0];
+//     let b = hash[1];
+//     let c = hash[2];
+//     let d = hash[3];
+//     let e = hash[4];
+//     let f = hash[5];
+//     let g = hash[6];
+//     let h = hash[7];
+
+//     for (let i = 0; i < 64; i += 1) {
+//       const s1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+//       const ch = (e & f) ^ (~e & g);
+//       const temp1 = (h + s1 + ch + SHA256_K[i] + words[i]) >>> 0;
+//       const s0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+//       const maj = (a & b) ^ (a & c) ^ (b & c);
+//       const temp2 = (s0 + maj) >>> 0;
+
+//       h = g;
+//       g = f;
+//       f = e;
+//       e = (d + temp1) >>> 0;
+//       d = c;
+//       c = b;
+//       b = a;
+//       a = (temp1 + temp2) >>> 0;
+//     }
+
+//     hash[0] = (hash[0] + a) >>> 0;
+//     hash[1] = (hash[1] + b) >>> 0;
+//     hash[2] = (hash[2] + c) >>> 0;
+//     hash[3] = (hash[3] + d) >>> 0;
+//     hash[4] = (hash[4] + e) >>> 0;
+//     hash[5] = (hash[5] + f) >>> 0;
+//     hash[6] = (hash[6] + g) >>> 0;
+//     hash[7] = (hash[7] + h) >>> 0;
+//   }
+
+//   const output = new Uint8Array(32);
+//   for (let i = 0; i < hash.length; i += 1) {
+//     output[i * 4] = hash[i] >>> 24;
+//     output[i * 4 + 1] = hash[i] >>> 16;
+//     output[i * 4 + 2] = hash[i] >>> 8;
+//     output[i * 4 + 3] = hash[i];
+//   }
+//   return output;
+// }
+
+async function sha256(input: Uint8Array): Promise<Uint8Array> {
+  const subtle = globalThis.crypto?.subtle;
+  if (subtle && typeof subtle.digest === 'function') {
+    const source = new ArrayBuffer(input.byteLength);
+    new Uint8Array(source).set(input);
+    return new Uint8Array(await subtle.digest('SHA-256', source));
+  }
+  // return sha256Fallback(input);
+  throw new Error('hashQueryParams only works in secure context.');
+}
+
 /**
  * 对查询参数进行 SHA-256 哈希编码，生成用于缓存的 key
  *
@@ -114,11 +233,11 @@ export async function hashQueryParams(
   const buffer = new TextEncoder().encode(str);
 
   // 4. SHA-256 哈希
-  const hashBuffer = await crypto.subtle.digest('SHA-256', buffer);
+  const hashBuffer = await sha256(buffer);
 
   // 5. 取前 N 字节（防越界）
   const safeBytes = Math.min(bytes, hashBuffer.byteLength);
-  const slice = new Uint8Array(hashBuffer, 0, safeBytes);
+  const slice = hashBuffer.subarray(0, safeBytes);
 
   // 6. 转为 BigInt 再转 36 进制
   let num = 0n;