@fast-china/utils 2.0.0 → 2.0.2

package/src/string/index.ts

@@ -1,328 +0,0 @@
-const defaultRandomAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-const defaultStringLocale = "en-US";
-const maximumRandomStringLength = 1_000_000;
-const maximumRandomValuesPerBatch = 16_384;
-const uuidV4Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
-
-/** 字符串随机 API 需要的 Web Crypto 最小能力。 */
-type RuntimeStringCrypto = Partial<Pick<Crypto, "getRandomValues" | "randomUUID">>;
-
-/** 字素分割需要的可选 Intl 能力。 */
-interface RuntimeStringIntl {
-	/** 可选 Segmenter 构造器；缺失时字素 API 使用内部兼容路径。 */
-	Segmenter?: typeof Intl.Segmenter;
-}
-
-/** 字符串工具延迟访问的平台全局对象最小视图。 */
-interface RuntimeStringGlobals {
-	/** 安全随机字符串与 UUID 所需的可选 Web Crypto 能力。 */
-	crypto?: RuntimeStringCrypto;
-	/** 字素分割所需的可选 Intl 能力。 */
-	Intl?: RuntimeStringIntl;
-}
-
-const runtimeGlobals = globalThis as unknown as RuntimeStringGlobals;
-
-/** 查询字符串解析结果；重复键保留为数组，不存在的键读取为 `undefined`。 */
-export type ParsedQueryParameters = Record<string, string | string[] | undefined>;
-
-/** 大小写与字素分割可接受的显式语言；省略时固定使用 `en-US` 以保持输出稳定。 */
-export type StringLocale = string | readonly string[] | undefined;
-
-/**
- * 获取字符串随机 API 所需的 Web Crypto 能力。
- *
- * @returns 具有 `getRandomValues` 的当前 Crypto 对象。
- * @throws `Error` 当平台没有安全随机能力；绝不回退到 `Math.random()`。
- */
-const requireWebCrypto = (): Crypto => {
-	const crypto = runtimeGlobals.crypto;
-	if (typeof crypto?.getRandomValues !== "function") {
-		throw new Error("Web Crypto random generation is unavailable in the current runtime.");
-	}
-	return crypto as Crypto;
-};
-
-/**
- * 从随机字节创建 UUID v4。
- *
- * @param bytes - 长度至少为 16 的随机字节；Version 与 Variant 位会被原地修改。
- * @returns 小写、带连字符的 RFC 4122 UUID v4。
- */
-const createUuidV4FromBytes = (bytes: Uint8Array): string => {
-	bytes[6] = ((bytes[6] ?? 0) & 15) | 64;
-	bytes[8] = ((bytes[8] ?? 0) & 63) | 128;
-	const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-};
-
-/**
- * 按用户可见字素切分文本。
- *
- * @param value - 待切分字符串。
- * @param locale - Segmenter 使用的显式语言；省略时使用固定默认值。
- * @returns 保留组合 Emoji、变音符号和连接序列的字素数组。
- * @throws `Error` 当平台缺少 `Intl.Segmenter`。
- */
-const splitGraphemes = (value: string, locale: StringLocale): string[] => {
-	const Segmenter = runtimeGlobals.Intl?.Segmenter;
-	if (typeof Segmenter !== "function") {
-		throw new Error("Intl.Segmenter is unavailable in the current runtime.");
-	}
-	const segmenter = new Segmenter(locale ?? defaultStringLocale, { granularity: "grapheme" });
-	return Array.from(segmenter.segment(value), ({ segment }) => segment);
-};
-
-/**
- * 重复执行 URI 组件解码，直到值稳定或达到深度上限。
- *
- * @param value - 不包含 URI 路径语义的编码组件。
- * @param maxDepth - 最大解码次数，默认 `10`。
- * @returns 解码稳定或达到上限后的组件文本。
- * @throws `URIError` 当任一层包含非法百分号序列；深度非法时抛出 `RangeError`。
- */
-export function decodeURIComponentRepeatedly(value: string, maxDepth = 10): string {
-	if (!Number.isSafeInteger(maxDepth) || maxDepth < 0) throw new RangeError("maxDepth must be a non-negative safe integer.");
-	let decoded = value;
-	for (let index = 0; index < maxDepth; index += 1) {
-		const next = decodeURIComponent(decoded);
-		if (next === decoded) break;
-		decoded = next;
-	}
-	return decoded;
-}
-
-/**
- * 解析带 `://` 的绝对 URL、`?query` 或纯查询字符串。
- *
- * @remarks 纯查询字符串值中的未编码 `?` 会作为值内容保留；片段标识及其后内容被忽略。
- * @param input - 完整 URL、带前导问号或不带前导问号的查询文本。
- * @returns 重复键对应字符串数组，空值保留为空字符串。
- */
-export function parseQueryString(input: string): ParsedQueryParameters {
-	const fragmentStart = input.indexOf("#");
-	const withoutFragment = fragmentStart < 0 ? input : input.slice(0, fragmentStart);
-	const isAbsoluteUrl = /^[a-z][a-z\d+.-]*:\/\//iu.test(withoutFragment);
-	const queryStart = withoutFragment.indexOf("?");
-	if (isAbsoluteUrl && queryStart < 0) return {};
-	const query = isAbsoluteUrl ? withoutFragment.slice(queryStart + 1) : withoutFragment.replace(/^\?/u, "");
-	const result: ParsedQueryParameters = {};
-	for (const [key, value] of new URLSearchParams(query)) {
-		const existing = Object.hasOwn(result, key) ? result[key] : undefined;
-		if (existing === undefined) {
-			// defineProperty 让 `__proto__` 成为普通自有键，不触发 Object.prototype Setter。
-			Object.defineProperty(result, key, { configurable: true, enumerable: true, value, writable: true });
-		} else if (Array.isArray(existing)) existing.push(value);
-		else Object.defineProperty(result, key, { configurable: true, enumerable: true, value: [existing, value], writable: true });
-	}
-	return result;
-}
-
-/**
- * 判断文本是否为任意合法 JSON 值，包括标量与 `null`。
- *
- * @param value - 待解析文本；纯空白不视为 JSON。
- * @returns `JSON.parse` 能完整解析时返回 `true`。
- */
-export function isValidJson(value: string): boolean {
-	if (value.trim().length === 0) return false;
-	try {
-		JSON.parse(value);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-/**
- * 按大小写边界、连字符、下划线与空白切分单词。
- *
- * @example `XMLHttp_request` 返回 `["XML", "Http", "request"]`。
- * @param value - 待拆分文本。
- * @returns 删除空项、保持输入顺序的单词数组。
- */
-export function splitWords(value: string): string[] {
-	return value
-		.trim()
-		.replace(/(\p{Ll}|\p{N})(\p{Lu})/gu, "$1 $2")
-		.replace(/(\p{Lu})(\p{Lu}\p{Ll})/gu, "$1 $2")
-		.split(/[\s_-]+/u)
-		.filter((part) => part.length > 0);
-}
-
-/**
- * 将首个 Unicode 码点转为大写。
- *
- * @param value - 输入文本；空字符串保持为空。
- * @param locale - 显式语言，默认固定为 `en-US`。
- * @returns 首个 Unicode 码点转换后的文本。
- */
-export function upperFirst(value: string, locale?: StringLocale): string {
-	const characters = Array.from(value);
-	const first = characters.shift();
-	return first === undefined ? "" : first.toLocaleUpperCase(locale ?? defaultStringLocale) + characters.join("");
-}
-
-/**
- * 将首个 Unicode 码点转为小写。
- *
- * @param value - 输入文本；空字符串保持为空。
- * @param locale - 显式语言，默认固定为 `en-US`。
- * @returns 首个 Unicode 码点转换后的文本。
- */
-export function lowerFirst(value: string, locale?: StringLocale): string {
-	const characters = Array.from(value);
-	const first = characters.shift();
-	return first === undefined ? "" : first.toLocaleLowerCase(locale ?? defaultStringLocale) + characters.join("");
-}
-
-/**
- * 将文本转换为 camelCase。
- *
- * @param value - 由大小写、连字符、下划线或空白分隔的文本。
- * @param locale - 大小写转换使用的语言，默认固定为 `en-US`。
- * @returns camelCase 文本。
- */
-export function camelCase(value: string, locale?: StringLocale): string {
-	return splitWords(value)
-		.map((part, index) => {
-			const normalized = part.toLocaleLowerCase(locale ?? defaultStringLocale);
-			return index === 0 ? normalized : upperFirst(normalized, locale);
-		})
-		.join("");
-}
-
-/**
- * 将文本转换为 PascalCase。
- *
- * @param value - 参数语义与 {@link camelCase} 一致。
- * @param locale - 大小写转换使用的显式语言。
- * @returns PascalCase 文本。
- */
-export function pascalCase(value: string, locale?: StringLocale): string {
-	return upperFirst(camelCase(value, locale), locale);
-}
-
-/**
- * 将文本转换为 kebab-case。
- *
- * @param value - 参数语义与 {@link camelCase} 一致。
- * @param locale - 大小写转换使用的显式语言。
- * @returns kebab-case 文本。
- */
-export function kebabCase(value: string, locale?: StringLocale): string {
-	return splitWords(value)
-		.map((part) => part.toLocaleLowerCase(locale ?? defaultStringLocale))
-		.join("-");
-}
-
-/**
- * 按 Unicode 字素簇截断文本，避免拆开 emoji、组合音标或代理对。
- *
- * @param value - 输入文本。
- * @param maxLength - 保留的最大字素簇数量。
- * @param suffix - 被截断时追加的文本，默认单字符省略号 `…`；不计入上限。
- * @param locale - 字素分割语言，默认固定为 `en-US`。
- * @returns 未超限时返回原字符串，否则返回截断内容与后缀。
- * @throws `RangeError` 当 `maxLength` 不是非负安全整数或 Locale 无效；缺少
- * `Intl.Segmenter` 时抛出 `Error`。
- */
-export function truncateGraphemes(value: string, maxLength: number, suffix = "…", locale?: StringLocale): string {
-	if (!Number.isSafeInteger(maxLength) || maxLength < 0) throw new RangeError("maxLength must be a non-negative safe integer.");
-	const segments = splitGraphemes(value, locale);
-	return segments.length > maxLength ? segments.slice(0, maxLength).join("") + suffix : value;
-}
-
-/**
- * 使用无偏 Web Crypto 随机数生成字符串。
- *
- * @param length - 字符数量，必须是 0 至 1,000,000 的安全整数。
- * @param alphabet - 不得为空、包含重复字符或超过 2^32 个 Unicode 码点。
- * @returns 由 `alphabet` 中 Unicode 码点组成的随机文本。
- * @throws `RangeError` 当长度或字母表非法；缺少 Web Crypto 时抛出 `Error`。
- */
-export function secureRandomString(length: number, alphabet: string = defaultRandomAlphabet): string {
-	if (!Number.isSafeInteger(length) || length < 0 || length > maximumRandomStringLength) {
-		throw new RangeError(`length must be a safe integer from 0 through ${maximumRandomStringLength}.`);
-	}
-	const characters = Array.from(alphabet);
-	if (characters.length === 0) throw new RangeError("alphabet cannot be empty.");
-	if (new Set(characters).size !== characters.length) throw new RangeError("alphabet cannot contain duplicate characters.");
-	if (characters.length > 0x1_0000_0000) throw new RangeError("alphabet cannot contain more than 2^32 characters.");
-	if (length === 0) return "";
-
-	const crypto = requireWebCrypto();
-	const uint32Range = 0x1_0000_0000;
-	// 丢弃不能平均映射到字母表的尾部区间，避免 `%` 造成前部字符概率偏高。
-	const acceptanceLimit = Math.floor(uint32Range / characters.length) * characters.length;
-	const result: string[] = [];
-	while (result.length < length) {
-		const remaining = length - result.length;
-		// 分批请求可控制临时内存，并避开 Web Crypto 单次随机数组大小限制。
-		const samples = crypto.getRandomValues(new Uint32Array(Math.min(remaining, maximumRandomValuesPerBatch)));
-		for (const sample of samples) {
-			if (sample >= acceptanceLimit) continue;
-			const character = characters[sample % characters.length];
-			if (character === undefined) continue;
-			result.push(character);
-			if (result.length === length) break;
-		}
-	}
-	return result.join("");
-}
-
-/**
- * 使用 Web Crypto 生成 RFC 4122 version 4 UUID。
- *
- * @returns 小写、带连字符的 UUID v4。
- * @throws 缺少 Web Crypto 时抛出 `Error`。
- */
-export function generateUuidV4(): string {
-	const crypto = requireWebCrypto();
-	if (typeof crypto.randomUUID === "function") return crypto.randomUUID();
-	return createUuidV4FromBytes(crypto.getRandomValues(new Uint8Array(16)));
-}
-
-/**
- * 判断字符串是否为 RFC 4122 version 4 UUID。
- *
- * @param value - 待验证文本；十六进制字母大小写均可。
- * @returns 版本位与 Variant 位均正确时返回 `true`。
- */
-export function isUuidV4(value: string): boolean {
-	return uuidV4Pattern.test(value);
-}
-
-/**
- * 转义 HTML 文本上下文中的五个特殊字符。
- *
- * @remarks 这不是 HTML 清洗器，不能让不可信文本安全进入 URL、CSS、脚本或属性名上下文。
- * @param value - 将作为 HTML 文本节点内容的字符串。
- * @returns 转义 `&`、`<`、`>`、双引号与单引号后的文本。
- */
-export function escapeHtml(value: string): string {
-	return value.replace(/[&<>"']/gu, (character) => {
-		switch (character) {
-			case "&":
-				return "&amp;";
-			case "<":
-				return "&lt;";
-			case ">":
-				return "&gt;";
-			case '"':
-				return "&quot;";
-			default:
-				return "&#39;";
-		}
-	});
-}
-
-/**
- * 把连续 Unicode 空白折叠为单个空格并删除两端空白。
- *
- * @param value - 输入文本。
- * @returns 规范化后的文本；全空白输入返回空字符串。
- */
-export function normalizeWhitespace(value: string): string {
-	return value.trim().replace(/\s+/gu, " ");
-}

package/src/vue/emits.ts

@@ -1,71 +0,0 @@
-import { computed } from "vue";
-
-import type { ComputedRef } from "vue";
-
-/** Vue Emits 对象中允许的校验器形状。 */
-type EmitValidator = ((...arguments_: never[]) => unknown) | null;
-/** 事件名到可选参数校验器的内部映射。 */
-type EmitsOptions = Record<string, EmitValidator>;
-/** 从校验器中提取事件参数；无校验器时保留未知参数。 */
-type EventArguments<Validator> = Validator extends (...arguments_: infer Arguments) => unknown ? Arguments : unknown[];
-/** 在类型层递归把 kebab-case 事件名转换为 PascalCase。 */
-type PascalEventName<Value extends string> = Value extends `${infer Head}-${infer Tail}`
-	? `${Capitalize<Head>}${PascalEventName<Tail>}`
-	: Capitalize<Value>;
-
-/** 把事件配置映射为 Vue `onXxx` 属性。 */
-export type EmitHandlers<Emits extends EmitsOptions> = {
-	[Name in keyof Emits as Name extends string ? `on${PascalEventName<Name>}` : never]: (...arguments_: EventArguments<Emits[Name]>) => void;
-};
-
-/**
- * 把事件名转换为 Vue Handler Prop 名称。
- *
- * @param eventName - Emits 对象中的原始事件名，可使用 kebab-case。
- * @returns `onPascalCase` 形式的属性名。
- * @throws `TypeError` 当事件名包含空片段或无法生成有效 Handler 名称。
- */
-const toHandlerName = (eventName: string): string => {
-	return `on${eventName
-		.split("-")
-		.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-		.join("")}`;
-};
-
-/**
- * 构建响应式 Vue 事件处理器。
- *
- * @param emits - Vue emits 配置对象。
- * @param emit - `setup` 上下文提供的 emit 函数。
- * @param ignoredEvents - 不需要向子组件透传的事件名。
- * @returns 随配置重新计算的事件处理器对象。
- */
-export function useEmits<Emits extends EmitsOptions>(
-	emits: Emits,
-	emit: (...arguments_: never[]) => unknown,
-	ignoredEvents: readonly (keyof Emits)[] = []
-): ComputedRef<Partial<EmitHandlers<Emits>>> {
-	const ignored = new Set<PropertyKey>(ignoredEvents);
-	const emitEvent = emit as unknown as (eventName: string, ...arguments_: unknown[]) => void;
-	return computed<Partial<EmitHandlers<Emits>>>(() => {
-		const handlers = {} as Partial<EmitHandlers<Emits>>;
-		const handlerNames = new Set<string>();
-		for (const eventName of Object.keys(emits)) {
-			if (ignored.has(eventName)) continue;
-			if (eventName.length === 0 || /\s/u.test(eventName)) throw new TypeError(`Invalid Vue event name: "${eventName}".`);
-			const handlerName = toHandlerName(eventName);
-			if (handlerNames.has(handlerName)) {
-				throw new TypeError(`Vue events map to the same handler property: "${handlerName}".`);
-			}
-			handlerNames.add(handlerName);
-			Object.defineProperty(handlers, handlerName, {
-				enumerable: true,
-				value: (...arguments_: unknown[]): void => {
-					emitEvent(eventName, ...arguments_);
-				},
-				writable: true,
-			});
-		}
-		return handlers;
-	});
-}

package/src/vue/expose.ts

@@ -1,11 +0,0 @@
-/**
- * 同时暴露组件实例能力并返回同一个对象，便于 `setup` 返回状态供 Vue Devtools 查看。
- *
- * @param expose - `setup` 上下文提供的 expose 函数。
- * @param exposed - 需要暴露的状态和方法。
- * @returns 原始 exposed 对象。
- */
-export function useExpose<Exposed extends object>(expose: (exposed?: Exposed) => void, exposed: Exposed): Exposed {
-	expose(exposed);
-	return exposed;
-}

package/src/vue/func.ts

@@ -1,17 +0,0 @@
-/** 可同步或异步返回结果的函数。 */
-export type AwaitableFunction<Arguments extends readonly unknown[], Result> = (...arguments_: Arguments) => Result | PromiseLike<Result>;
-
-/**
- * 统一执行同步或异步函数，异常保持原样向调用方传播。
- *
- * @param function_ - 可选的待执行函数。
- * @param arguments_ - 原样传入函数的参数。
- * @returns 函数结果；未传函数时返回 `undefined`。
- */
-export async function callOptionalFunction<Arguments extends readonly unknown[], Result>(
-	function_: AwaitableFunction<Arguments, Result> | null | undefined,
-	...arguments_: Arguments
-): Promise<Awaited<Result> | undefined> {
-	if (function_ === null || function_ === undefined) return undefined;
-	return await function_(...arguments_);
-}

package/src/vue/index.ts

@@ -1,13 +0,0 @@
-/**
- * Vue 2.7/3 helpers re-exported by the package root entry.
- *
- * @packageDocumentation
- */
-export * from "./emits.js";
-export * from "./expose.js";
-export * from "./func.js";
-export * from "./install.js";
-export * from "./props.js";
-export * from "./render.js";
-export * from "./slots.js";
-export * from "./with.js";

package/src/vue/install.ts

@@ -1,185 +0,0 @@
-/** Vue 2.7 构造器与 Vue 3 App 共有的组件、指令注册能力。 */
-export interface VueRegistrationTarget {
-	/**
-	 * 读取或注册全局组件。
-	 *
-	 * @param name - 全局组件名。
-	 * @param component - 注册时传入的组件；省略时读取现有组件。
-	 * @returns Vue 平台返回的现有组件、注册结果或目标自身。
-	 */
-	component: (name: string, component?: unknown) => unknown;
-	/**
-	 * 读取或注册全局指令。
-	 *
-	 * @param name - 不带 `v-` 的全局指令名。
-	 * @param directive - 注册时传入的指令；省略时读取现有指令。
-	 * @returns Vue 平台返回的现有指令、注册结果或目标自身。
-	 */
-	directive: (name: string, directive?: unknown) => unknown;
-}
-
-/** Vue 组件对象、函数组件或指令对象可接受的最小结构类型。 */
-export type VueInstallValue = object | ((...arguments_: never[]) => unknown);
-
-/** 为 Vue 组件或指令附加供 Vue 2.7 `Vue.use()` 与 Vue 3 `app.use()` 调用的安装能力。 */
-export type Installable<Value> = Value & {
-	/**
-	 * 把当前组件或指令安装到 Vue 2.7 构造器或 Vue 3 App。
-	 * @param target - Vue 2.7 构造器或 Vue 3 App 实例。
-	 */
-	install: (target: unknown) => void;
-};
-
-/** TSX 组件安装类型；与 {@link Installable} 保持同一运行时契约。 */
-export type TSXWithInstall<Value> = Installable<Value>;
-
-/**
- * 校验 Vue 插件安装目标。
- *
- * @param value - Vue 2.7 构造器或 Vue 3 App 实例。
- * @returns 只包含组件和指令注册能力的结构化目标。
- * @throws `TypeError` 当目标缺少 `component` 或 `directive` 方法。
- */
-const assertTarget = (value: unknown): VueRegistrationTarget => {
-	if ((typeof value !== "object" && typeof value !== "function") || value === null) {
-		throw new TypeError("Vue plugin installation requires a Vue constructor or App.");
-	}
-	const target = value as Partial<VueRegistrationTarget>;
-	if (typeof target.component !== "function" || typeof target.directive !== "function") {
-		throw new TypeError("Vue plugin installation requires component() and directive() registration methods.");
-	}
-	return target as VueRegistrationTarget;
-};
-
-/**
- * 提取组件的全局注册名称。
- *
- * @param component - 待注册组件。
- * @returns 去除外围空白后的显式名称。
- * @throws `TypeError` 当组件没有非空字符串名称。
- */
-const getComponentName = (component: VueInstallValue): string => {
-	const name = (component as { name?: unknown }).name;
-	if (typeof name !== "string" || name.length === 0 || /\s/u.test(name)) {
-		throw new TypeError("Installable Vue components must expose a non-empty name without whitespace.");
-	}
-	return name;
-};
-
-/** 预检完成、可以无失败注册的组件动作。 */
-interface ComponentRegistration {
-	/** 已校验的组件引用。 */
-	component: VueInstallValue;
-	/** 已校验的组件名称。 */
-	name: string;
-	/** 目标中是否已经注册了完全相同的组件引用。 */
-	registered: boolean;
-}
-
-/**
- * 预检单个组件注册。
- *
- * @remarks 先读取同名组件并完成冲突判断，再返回延迟执行动作；调用方可以在所有组件预检通过后统一提交。
- * @param target - 已校验的 Vue 注册目标。
- * @param component - 待注册组件。
- * @returns 已校验的组件引用、名称和目标中是否已经存在同一引用。
- * @throws `Error` 当同名位置已由其他组件占用。
- */
-const prepareComponentRegistration = (target: VueRegistrationTarget, component: VueInstallValue): ComponentRegistration => {
-	const name = getComponentName(component);
-	const existing = target.component(name);
-	if (existing !== undefined && existing !== component) {
-		throw new Error(`Vue component name "${name}" is already registered by another component.`);
-	}
-	return { component, name, registered: existing === component };
-};
-
-/**
- * 为主组件附加 Vue 2.7 `Vue.use()` 与 Vue 3 `app.use()` 安装能力。
- *
- * @remarks 函数会直接为 `main` 定义附属组件属性和 `install`。所有组件名称、附属属性
- * 冲突会在修改 `main` 前完成校验；安装到 App 时也会先预检全部全局名称，再统一注册。
- * @param main - 具有非空 `name` 的组件。
- * @param extras - 同时注册并以可枚举属性挂到主组件的附属组件映射。
- * @returns 原始 `main` 引用，并附加类型化的 `install` 与 `extras` 属性。
- * @throws `TypeError` 当组件缺少合法名称、已有 `install`、附属键或名称发生冲突。
- * @throws `Error` 当安装目标中同名位置已经注册其他组件。
- */
-export function withInstall<Main extends VueInstallValue, Extras extends Record<string, VueInstallValue> = Record<never, never>>(
-	main: Main,
-	extras?: Extras
-): Installable<Main> & Extras {
-	const componentNames = new Set([getComponentName(main)]);
-	if ("install" in Object(main)) throw new TypeError("The Vue component already defines an install property.");
-	const extraEntries = Object.entries(extras ?? {});
-	if (extras !== undefined && Object.getOwnPropertySymbols(extras).some((key) => Object.prototype.propertyIsEnumerable.call(extras, key))) {
-		throw new TypeError("Vue component extras must use string property names.");
-	}
-	for (const [key, component] of extraEntries) {
-		const componentName = getComponentName(component);
-		if (componentNames.has(componentName)) throw new TypeError(`Vue component name "${componentName}" is registered more than once.`);
-		componentNames.add(componentName);
-		if (key === "install" || key in Object(main)) {
-			throw new TypeError(`Vue component extra "${key}" would overwrite a property on the main component.`);
-		}
-	}
-	const installable = main as Installable<Main> & Extras;
-	for (const [key, component] of extraEntries) {
-		Object.defineProperty(installable, key, { configurable: true, enumerable: true, value: component, writable: true });
-	}
-	installable.install = (value: unknown): void => {
-		const target = assertTarget(value);
-		// 先完成全部冲突检查，再统一注册，避免安装到一半留下部分全局组件。
-		const registrations = [main, ...extraEntries.map(([, component]) => component)].map((component) =>
-			prepareComponentRegistration(target, component)
-		);
-		for (const registration of registrations) {
-			if (!registration.registered) target.component(registration.name, registration.component);
-		}
-	};
-	return installable;
-}
-
-/**
- * 为不需要单独注册的附属组件附加空安装函数。
- *
- * @remarks 适用于只能作为主组件附属属性使用、但仍需满足 Vue Plugin 类型的组件。
- * 函数直接修改并返回传入组件，不会向 Vue 全局组件表注册内容。
- * @param component - 尚未定义或继承 `install` 属性的组件。
- * @returns 原组件引用及无副作用的 `install` 方法。
- * @throws `TypeError` 当组件自身或原型链已经存在 `install`。
- */
-export function withNoopInstall<Value extends VueInstallValue>(component: Value): TSXWithInstall<Value> {
-	if ("install" in Object(component)) throw new TypeError("The Vue component already defines an install property.");
-	const installable = component as TSXWithInstall<Value>;
-	installable.install = (): void => undefined;
-	return installable;
-}
-
-/**
- * 为 Vue 2.7/3 指令附加插件安装能力。
- *
- * @remarks 函数直接修改并返回指令。安装时重复注册同一引用保持幂等，不会覆盖同名的
- * 其他指令。名称只传给 `directive()`，不得包含 `v-` 前缀。
- * @param directive - 尚未定义或继承 `install` 属性的 Vue 指令对象。
- * @param name - 非空、无空白且不以 `v-` 开头的全局指令名。
- * @returns 原指令引用及 Vue Plugin `install` 方法。
- * @throws `TypeError` 当名称非法、指令已有 `install`，或安装目标无效。
- * @throws `Error` 当安装目标中同名位置已经注册其他指令。
- */
-export function withInstallDirective<Value extends VueInstallValue>(directive: Value, name: string): Installable<Value> {
-	if (name.length === 0 || /\s/u.test(name) || name.startsWith("v-")) {
-		throw new TypeError("Installable Vue directives require a name without whitespace or a v- prefix.");
-	}
-	if ("install" in Object(directive)) throw new TypeError("The Vue directive already defines an install property.");
-	const installable = directive as Installable<Value>;
-	installable.install = (value: unknown): void => {
-		const target = assertTarget(value);
-		const existing = target.directive(name);
-		if (existing !== undefined && existing !== directive) {
-			throw new Error(`Vue directive name "${name}" is already registered by another directive.`);
-		}
-		if (existing !== directive) target.directive(name, directive);
-	};
-	return installable;
-}

package/src/vue/props.ts

@@ -1,39 +0,0 @@
-import { computed } from "vue";
-
-import type { ComputedRef, PropType } from "vue";
-
-/**
- * 为 Vue 运行时 Props 构造器附加泛型类型。
- *
- * @remarks 该函数只帮助 TypeScript 建模，不验证运行时值与 `Value` 一致；调用方仍应
- * 传入 Vue 支持的构造器或构造器数组。
- * @param runtimeType - Vue 支持的运行时构造器或构造器数组。
- * @returns 同一引用，仅在类型层收窄为 `PropType<Value>`。
- */
-export function definePropType<Value>(runtimeType: unknown): PropType<Value> {
-	return runtimeType as PropType<Value>;
-}
-
-/**
- * 构建需要透传给子组件的响应式 Props。
- *
- * @param props - Vue `setup` 接收的只读响应式 Props 对象。
- * @param rawProps - 子组件的运行时 Props 配置。
- * @param ignoredProps - 不需要透传的 Props 名称。
- * @returns 只包含 `rawProps` 声明键且随 Props 更新的 ComputedRef。
- */
-export function useProps<Props extends object, RawProps extends object>(
-	props: Props,
-	rawProps: RawProps,
-	ignoredProps: readonly (keyof RawProps)[] = []
-): ComputedRef<Pick<Props, Extract<keyof Props, keyof RawProps>>> {
-	const ignored = new Set<PropertyKey>(ignoredProps);
-	return computed<Pick<Props, Extract<keyof Props, keyof RawProps>>>(() => {
-		const result = {} as Pick<Props, Extract<keyof Props, keyof RawProps>>;
-		for (const key of Reflect.ownKeys(rawProps)) {
-			if (ignored.has(key) || !Object.hasOwn(props, key)) continue;
-			Object.defineProperty(result, key, { configurable: true, enumerable: true, value: Reflect.get(props, key), writable: true });
-		}
-		return result;
-	});
-}