vanilla-jui 1.7.1 → 1.7.2

package/src/utilities/merge.ts

@@ -0,0 +1,97 @@
+import { isPlainObject } from './object.ts';
+
+export type MergeStrategy =
+  | 'replace'
+  | 'shallow'
+  | 'deep'
+  | ((
+      defaultValue: unknown,
+      inputValue: unknown,
+      context: MergeContext
+    ) => unknown);
+
+export interface MergeContext {
+  key: string;
+  path: string;
+}
+
+type LooseRecord = Record<string, unknown>;
+
+const UNSAFE_KEYS = new Set(['__proto__', 'prototype', 'constructor']);
+
+function isSafeKey(key: string): boolean {
+  return !UNSAFE_KEYS.has(key);
+}
+
+export function cloneConfigValue<T>(value: T): T {
+  if (Array.isArray(value)) return value.map(cloneConfigValue) as T;
+  if (!isPlainObject(value)) return value;
+
+  const result: LooseRecord = {};
+  for (const [key, child] of Object.entries(value as LooseRecord)) {
+    if (!isSafeKey(key)) continue;
+    result[key] = cloneConfigValue(child);
+  }
+  return result as T;
+}
+
+export function mergeShallowConfig(
+  defaultValue: unknown,
+  inputValue: unknown
+): unknown {
+  if (!isPlainObject(defaultValue) || !isPlainObject(inputValue)) {
+    return cloneConfigValue(inputValue);
+  }
+
+  const result = cloneConfigValue(defaultValue) as LooseRecord;
+  for (const [key, value] of Object.entries(inputValue as LooseRecord)) {
+    if (!isSafeKey(key)) continue;
+    result[key] = cloneConfigValue(value);
+  }
+  return result;
+}
+
+export function mergeDeepConfig(
+  defaultValue: unknown,
+  inputValue: unknown
+): unknown {
+  if (!isPlainObject(defaultValue) || !isPlainObject(inputValue)) {
+    return cloneConfigValue(inputValue);
+  }
+
+  const result = cloneConfigValue(defaultValue) as LooseRecord;
+  for (const [key, value] of Object.entries(inputValue as LooseRecord)) {
+    if (!isSafeKey(key)) continue;
+    const current = result[key];
+    result[key] =
+      isPlainObject(current) && isPlainObject(value)
+        ? mergeDeepConfig(current, value)
+        : cloneConfigValue(value);
+  }
+  return result;
+}
+
+export function mergeConfigValue(
+  defaultValue: unknown,
+  inputValue: unknown,
+  strategy: MergeStrategy | undefined,
+  context: MergeContext
+): unknown {
+  if (typeof strategy === 'function') {
+    return strategy(
+      cloneConfigValue(defaultValue),
+      cloneConfigValue(inputValue),
+      context
+    );
+  }
+
+  if (strategy === 'shallow') {
+    return mergeShallowConfig(defaultValue, inputValue);
+  }
+
+  if (strategy === 'deep') {
+    return mergeDeepConfig(defaultValue, inputValue);
+  }
+
+  return cloneConfigValue(inputValue);
+}

package/src/utilities/types.ts

@@ -55,14 +55,7 @@ export type ValidateCondition =
       message?: string;
     };
 
-export interface NormalizeContext<TInput extends LooseRecord = LooseRecord> {
-  key: string;
-  input: TInput;
-  options: LooseRecord;
-  schema: ResolveSchema<TInput>;
-}
-
-export interface ParamRule<TInput extends LooseRecord = LooseRecord> {
+export interface ParamRule<_TInput extends LooseRecord = LooseRecord> {
   type?: TypeRule;
   types?: TypeRule;
   required?: boolean;
@@ -78,13 +71,11 @@ export interface ParamRule<TInput extends LooseRecord = LooseRecord> {
   lessThan?: number;
   plain?: boolean;
   items?: ParamRuleInput;
-  shape?: ResolveSchema;
+  shape?: ParamShapeSchema;
   conditions?: ValidateCondition | readonly ValidateCondition[];
   validate?: (value: unknown) => boolean;
   message?: string;
-  normalize?: (value: unknown, context: NormalizeContext<TInput>) => unknown;
   default?: unknown;
-  factory?: boolean;
   [key: string]: unknown;
 }
 
@@ -92,21 +83,11 @@ export type ParamRuleInput<TInput extends LooseRecord = LooseRecord> =
   | TypeRule
   | ParamRule<TInput>;
 
-export type ResolveSchema<TInput extends LooseRecord = LooseRecord> = Record<
+export type ParamShapeSchema<TInput extends LooseRecord = LooseRecord> = Record<
   string,
   ParamRuleInput<TInput>
 >;
 
-export type ResolvedProps<TSchema extends object> = LooseRecord & {
-  [Key in keyof TSchema]: unknown;
-};
-
-function cloneDefault<T>(value: T): T {
-  if (Array.isArray(value)) return value.slice() as T;
-  if (isPlainObject(value)) return { ...(value as LooseRecord) } as T;
-  return value;
-}
-
 function normalizeRule<TInput extends LooseRecord = LooseRecord>(
   rule: ParamRuleInput<TInput> = {}
 ): ParamRule<TInput> {
@@ -332,66 +313,6 @@ export function validateParam<TInput extends LooseRecord = LooseRecord>(
   return value;
 }
 
-export function resolveProps<
-  TInput extends LooseRecord,
-  TSchema extends ResolveSchema<TInput>,
->(
-  input: TInput | null | undefined = {} as TInput,
-  schema: TSchema = {} as TSchema,
-  namespace = 'Options'
-): TInput & ResolvedProps<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 = { ...sourceRecord };
-  const entries = Object.entries(schema || {}) as Array<
-    [string, ParamRuleInput<TInput>]
-  >;
-
-  for (const [key, rawRule] of entries) {
-    const rule = normalizeRule<TInput>(rawRule);
-    resolved[key] = Object.hasOwn(sourceRecord, key)
-      ? sourceRecord[key]
-      : resolveDefault(rule);
-  }
-
-  for (const [key, rawRule] of entries) {
-    const rule = normalizeRule<TInput>(rawRule);
-    if (typeof rule.normalize === 'function') {
-      resolved[key] = rule.normalize(resolved[key], {
-        key,
-        input: sourceRecord,
-        options: resolved,
-        schema,
-      });
-    }
-  }
-
-  for (const [key, rule] of entries) {
-    validateParam(key, resolved[key], rule, namespace);
-  }
-
-  return resolved as TInput & ResolvedProps<TSchema>;
-}
-
-interface DefaultRule {
-  default?: unknown;
-  factory?: boolean;
-}
-
-function resolveDefault(rule: DefaultRule): unknown {
-  if (!Object.hasOwn(rule, 'default')) return undefined;
-  const defaultValue = rule.default;
-  const value =
-    rule.factory && typeof defaultValue === 'function'
-      ? defaultValue()
-      : defaultValue;
-  return cloneDefault(value);
-}
-
 /**
  * 判断是否为普通可构造函数（排除箭头函数和类）。
  * @param fn - 需要判断的值

package/src/utilities/validator.ts

@@ -7,12 +7,8 @@ import {
   resolveElement,
 } from '../utilities/dom.ts';
 import { createEventManager } from '../utilities/events.ts';
-import { isPlainObject } from '../utilities/object.ts';
-import {
-  type ResolveSchema,
-  resolveProps,
-  validateParam,
-} from '../utilities/types.ts';
+import { type ConfigSchema, resolveConfig } from '../utilities/config.ts';
+import { validateParam } from '../utilities/types.ts';
 
 type ValidatorElement =
   | HTMLInputElement
@@ -99,21 +95,14 @@ const VALIDATOR_PROPS_SCHEMA = {
   vanilla: { default: false, type: 'boolean' },
   className: {
     default: DEFAULT_CLASS_NAMES,
-    type: 'object',
-    normalize: (value: unknown) => resolveClassNames(value),
+    type: 'plainObject',
+    merge: 'shallow',
   },
   onSubmit: { default: null, types: ['function', 'null'] },
-} satisfies ResolveSchema<ValidatorProps>;
-
-function resolveClassNames(value: unknown): ValidatorClassNames {
-  return {
-    ...DEFAULT_CLASS_NAMES,
-    ...(isPlainObject(value) ? (value as ValidatorClassNameConfig) : {}),
-  } as ValidatorClassNames;
-}
+} satisfies ConfigSchema<ValidatorProps>;
 
 function normalizeProps(input: ValidatorProps): ResolvedValidatorProps {
-  const props = resolveProps(input, VALIDATOR_PROPS_SCHEMA, 'Validator.props');
+  const props = resolveConfig(input, VALIDATOR_PROPS_SCHEMA, 'Validator.props');
   return {
     rules: props.rules as Record<string, ValidatorRule>,
     messages: props.messages as ValidatorMessageMap,