wevu 6.7.3 → 6.7.4

package/dist/api.d.mts

@@ -0,0 +1 @@
+export * from "@wevu/api";

package/dist/api.mjs

@@ -0,0 +1,2 @@
+export * from "@wevu/api";
+export {};

package/dist/compiler.mjs

@@ -1,3 +1,2 @@
-export * from "@wevu/compiler"
-
-export {  };
+export * from "@wevu/compiler";
+export {};

package/dist/defineProperty-JH0tR899.mjs

@@ -0,0 +1,39 @@
+//#region \0@oxc-project+runtime@0.115.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+export { _defineProperty as t };

package/dist/fetch.d.mts

@@ -0,0 +1,26 @@
+//#region src/fetch.d.ts
+interface WevuFetchInit {
+  method?: string;
+  headers?: unknown;
+  body?: unknown;
+  signal?: AbortSignal | null;
+  [key: string]: unknown;
+}
+interface RequestLikeInput {
+  url: string;
+  method?: string;
+  headers?: unknown;
+  signal?: AbortSignal | null;
+  bodyUsed?: boolean;
+  clone?: () => {
+    arrayBuffer?: () => Promise<ArrayBuffer>;
+    text?: () => Promise<string>;
+  };
+}
+type WevuFetchInput = string | URL | RequestLikeInput;
+/**
+ * @description 使用 @wevu/api 的 request 能力实现 fetch 语义对齐
+ */
+declare function fetch(input: WevuFetchInput, init?: WevuFetchInit): Promise<Response>;
+//#endregion
+export { WevuFetchInit, fetch };

package/dist/fetch.mjs

@@ -0,0 +1,345 @@
+import { t as _defineProperty } from "./defineProperty-JH0tR899.mjs";
+import { wpi } from "@wevu/api";
+//#region src/fetch.ts
+let _Symbol$iterator, _Symbol$toStringTag;
+const hasOwn = Object.prototype.hasOwnProperty;
+const REQUEST_METHODS = [
+	"GET",
+	"HEAD",
+	"OPTIONS",
+	"POST",
+	"PUT",
+	"DELETE",
+	"TRACE",
+	"CONNECT"
+];
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+function createAbortError() {
+	if (typeof DOMException === "function") return new DOMException("The operation was aborted.", "AbortError");
+	const error = /* @__PURE__ */ new Error("The operation was aborted.");
+	error.name = "AbortError";
+	return error;
+}
+function normalizeMethod(method) {
+	const normalized = (method !== null && method !== void 0 ? method : "GET").toUpperCase();
+	if (REQUEST_METHODS.includes(normalized)) return normalized;
+	return "GET";
+}
+function setHeader(target, key, value) {
+	const headerName = key.trim();
+	if (!headerName) return;
+	const normalizedValue = String(value);
+	for (const existingKey of Object.keys(target)) if (existingKey.toLowerCase() === headerName.toLowerCase() && existingKey !== headerName) {
+		delete target[existingKey];
+		break;
+	}
+	target[headerName] = normalizedValue;
+}
+function hasHeader(target, key) {
+	const normalized = key.toLowerCase();
+	return Object.keys(target).some((item) => item.toLowerCase() === normalized);
+}
+function mergeHeaderSource(target, source) {
+	if (!source) return;
+	if (typeof source.forEach === "function") {
+		source.forEach((value, key) => {
+			setHeader(target, key, value);
+		});
+		return;
+	}
+	if (typeof source[Symbol.iterator] === "function") {
+		for (const item of source) {
+			if (!item || item.length < 2) continue;
+			setHeader(target, item[0], item[1]);
+		}
+		return;
+	}
+	if (isObject(source)) for (const [key, value] of Object.entries(source)) {
+		if (Array.isArray(value)) {
+			setHeader(target, key, value.join(", "));
+			continue;
+		}
+		setHeader(target, key, value);
+	}
+}
+function toHeaderMap(source) {
+	const headers = {};
+	mergeHeaderSource(headers, source);
+	return headers;
+}
+function encodeText(text) {
+	if (typeof TextEncoder === "function") return new TextEncoder().encode(text).buffer;
+	const bytes = new Uint8Array(text.length);
+	for (let i = 0; i < text.length; i++) bytes[i] = text.charCodeAt(i) & 255;
+	return bytes.buffer;
+}
+function decodeText(buffer) {
+	if (typeof TextDecoder === "function") return new TextDecoder().decode(buffer);
+	const view = new Uint8Array(buffer);
+	let text = "";
+	for (const byte of view) text += String.fromCharCode(byte);
+	return text;
+}
+function cloneBuffer(buffer) {
+	return buffer.slice(0);
+}
+function cloneViewBuffer(view) {
+	const copied = new Uint8Array(view.byteLength);
+	copied.set(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+	return copied.buffer;
+}
+function isRequestLikeInput(input) {
+	return isObject(input) && typeof input.url === "string";
+}
+async function extractRequestBodyFromInput(input) {
+	if (!input || typeof input.clone !== "function") return;
+	if (input.bodyUsed) throw new TypeError("Failed to execute fetch: request body is already used");
+	const cloned = input.clone();
+	if (cloned === null || cloned === void 0 ? void 0 : cloned.arrayBuffer) return cloned.arrayBuffer();
+	if (cloned === null || cloned === void 0 ? void 0 : cloned.text) return cloned.text();
+}
+async function normalizeRequestBody(body, headers) {
+	if (body == null) return;
+	if (typeof body === "string") {
+		if (!hasHeader(headers, "content-type")) headers["content-type"] = "text/plain;charset=UTF-8";
+		return body;
+	}
+	if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) {
+		if (!hasHeader(headers, "content-type")) headers["content-type"] = "application/x-www-form-urlencoded;charset=UTF-8";
+		return body.toString();
+	}
+	if (body instanceof ArrayBuffer) return cloneBuffer(body);
+	if (ArrayBuffer.isView(body)) return cloneViewBuffer(body);
+	if (typeof Blob !== "undefined" && body instanceof Blob) {
+		if (body.type && !hasHeader(headers, "content-type")) headers["content-type"] = body.type;
+		return body.arrayBuffer();
+	}
+	if (typeof FormData !== "undefined" && body instanceof FormData) throw new TypeError("Failed to execute fetch: FormData body is not supported in wevu/fetch");
+	return String(body);
+}
+async function resolveRequestMeta(input, init = {}) {
+	var _init$method, _ref, _init$signal;
+	const requestInput = isRequestLikeInput(input) ? input : void 0;
+	const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : requestInput === null || requestInput === void 0 ? void 0 : requestInput.url;
+	if (!url) throw new TypeError("Failed to execute fetch: invalid request url");
+	const method = normalizeMethod((_init$method = init.method) !== null && _init$method !== void 0 ? _init$method : requestInput === null || requestInput === void 0 ? void 0 : requestInput.method);
+	const headers = toHeaderMap(requestInput === null || requestInput === void 0 ? void 0 : requestInput.headers);
+	mergeHeaderSource(headers, init.headers);
+	const rawBody = hasOwn.call(init, "body") ? init.body : await extractRequestBodyFromInput(requestInput);
+	if ((method === "GET" || method === "HEAD") && rawBody != null) throw new TypeError("Failed to execute fetch: GET/HEAD request cannot have body");
+	return {
+		url,
+		method,
+		headers,
+		body: await normalizeRequestBody(rawBody, headers),
+		signal: (_ref = (_init$signal = init.signal) !== null && _init$signal !== void 0 ? _init$signal : requestInput === null || requestInput === void 0 ? void 0 : requestInput.signal) !== null && _ref !== void 0 ? _ref : null
+	};
+}
+function readResponseDataAsArrayBuffer(data) {
+	if (data == null) return Promise.resolve(/* @__PURE__ */ new ArrayBuffer(0));
+	if (data instanceof ArrayBuffer) return Promise.resolve(cloneBuffer(data));
+	if (ArrayBuffer.isView(data)) {
+		const view = data;
+		return Promise.resolve(cloneViewBuffer(view));
+	}
+	if (typeof data === "string") return Promise.resolve(encodeText(data));
+	if (typeof Blob !== "undefined" && data instanceof Blob) return data.arrayBuffer();
+	return Promise.resolve(encodeText(JSON.stringify(data)));
+}
+_Symbol$iterator = Symbol.iterator;
+var WevuHeadersFallback = class {
+	constructor(init) {
+		_defineProperty(this, "store", /* @__PURE__ */ new Map());
+		if (!init) return;
+		for (const [key, value] of Object.entries(init)) this.set(key, value);
+	}
+	append(key, value) {
+		const current = this.get(key);
+		if (!current) {
+			this.set(key, value);
+			return;
+		}
+		this.set(key, `${current}, ${value}`);
+	}
+	set(key, value) {
+		const normalized = key.toLowerCase();
+		this.store.set(normalized, {
+			key,
+			value
+		});
+	}
+	get(key) {
+		var _this$store$get$value, _this$store$get;
+		return (_this$store$get$value = (_this$store$get = this.store.get(key.toLowerCase())) === null || _this$store$get === void 0 ? void 0 : _this$store$get.value) !== null && _this$store$get$value !== void 0 ? _this$store$get$value : null;
+	}
+	has(key) {
+		return this.store.has(key.toLowerCase());
+	}
+	delete(key) {
+		this.store.delete(key.toLowerCase());
+	}
+	forEach(callback) {
+		for (const item of this.store.values()) callback(item.value, item.key);
+	}
+	entries() {
+		return Array.from(this.store.values(), (item) => [item.key, item.value])[Symbol.iterator]();
+	}
+	keys() {
+		return Array.from(this.store.values(), (item) => item.key)[Symbol.iterator]();
+	}
+	values() {
+		return Array.from(this.store.values(), (item) => item.value)[Symbol.iterator]();
+	}
+	[_Symbol$iterator]() {
+		return this.entries();
+	}
+};
+function createHeadersContainer(headers) {
+	if (typeof Headers === "function") return new Headers(headers);
+	return new WevuHeadersFallback(headers);
+}
+function cloneHeadersToMap(headers) {
+	const result = {};
+	headers.forEach((value, key) => {
+		setHeader(result, key, value);
+	});
+	return result;
+}
+_Symbol$toStringTag = Symbol.toStringTag;
+var WevuResponseFallback = class WevuResponseFallback {
+	constructor(data, options) {
+		_defineProperty(this, "consumed", false);
+		_defineProperty(this, "responseData", void 0);
+		_defineProperty(this, "headers", void 0);
+		_defineProperty(this, "ok", void 0);
+		_defineProperty(this, "redirected", false);
+		_defineProperty(this, "status", void 0);
+		_defineProperty(this, "statusText", "");
+		_defineProperty(this, "type", "basic");
+		_defineProperty(this, "url", void 0);
+		_defineProperty(this, "body", null);
+		_defineProperty(this, _Symbol$toStringTag, "Response");
+		this.responseData = data;
+		this.status = options.status;
+		this.url = options.url;
+		this.ok = this.status >= 200 && this.status < 300;
+		this.headers = createHeadersContainer(options.headers);
+	}
+	get bodyUsed() {
+		return this.consumed;
+	}
+	consumeBody(reader) {
+		if (this.consumed) return Promise.reject(/* @__PURE__ */ new TypeError("Failed to execute fetch: body stream already read"));
+		this.consumed = true;
+		return reader();
+	}
+	arrayBuffer() {
+		return this.consumeBody(() => readResponseDataAsArrayBuffer(this.responseData));
+	}
+	blob() {
+		return this.consumeBody(async () => {
+			if (typeof Blob !== "function") throw new TypeError("Blob is unavailable in current runtime");
+			const arrayBuffer = await readResponseDataAsArrayBuffer(this.responseData);
+			return new Blob([arrayBuffer]);
+		});
+	}
+	formData() {
+		return this.consumeBody(async () => {
+			throw new TypeError("formData is not supported in wevu/fetch response fallback");
+		});
+	}
+	json() {
+		return this.consumeBody(async () => {
+			if (isObject(this.responseData) || Array.isArray(this.responseData)) return this.responseData;
+			const text = await this.textFromRaw();
+			return JSON.parse(text);
+		});
+	}
+	text() {
+		return this.consumeBody(() => this.textFromRaw());
+	}
+	clone() {
+		return new WevuResponseFallback(this.responseData, {
+			headers: cloneHeadersToMap(this.headers),
+			status: this.status,
+			url: this.url
+		});
+	}
+	async textFromRaw() {
+		if (typeof this.responseData === "string") return this.responseData;
+		return decodeText(await readResponseDataAsArrayBuffer(this.responseData));
+	}
+};
+function createFetchResponse(data, status, headers, url) {
+	if (typeof Response === "function") {
+		const nativeBody = typeof data === "string" ? data : data instanceof ArrayBuffer ? data : ArrayBuffer.isView(data) ? cloneViewBuffer(data) : JSON.stringify(data !== null && data !== void 0 ? data : "");
+		const normalizedStatus = Number.isFinite(status) && status >= 200 && status <= 599 ? status : 200;
+		try {
+			return new Response(nativeBody, {
+				status: normalizedStatus,
+				headers
+			});
+		} catch (_unused) {}
+	}
+	return new WevuResponseFallback(data, {
+		headers,
+		status,
+		url
+	});
+}
+function isRequestTask(value) {
+	return isObject(value) && typeof value.abort === "function";
+}
+/**
+* @description 使用 @wevu/api 的 request 能力实现 fetch 语义对齐
+*/
+function fetch(input, init) {
+	return resolveRequestMeta(input, init).then((meta) => {
+		var _meta$signal;
+		if ((_meta$signal = meta.signal) === null || _meta$signal === void 0 ? void 0 : _meta$signal.aborted) return Promise.reject(createAbortError());
+		return new Promise((resolve, reject) => {
+			let settled = false;
+			let aborted = false;
+			const onAbort = () => {
+				if (settled) return;
+				aborted = true;
+				requestTask === null || requestTask === void 0 || requestTask.abort();
+				settled = true;
+				reject(createAbortError());
+			};
+			if (meta.signal) meta.signal.addEventListener("abort", onAbort, { once: true });
+			const cleanup = () => {
+				if (meta.signal) meta.signal.removeEventListener("abort", onAbort);
+			};
+			const requestResult = wpi.request({
+				url: meta.url,
+				method: meta.method,
+				header: meta.headers,
+				data: meta.body,
+				responseType: "arraybuffer",
+				success: (res) => {
+					if (settled) return;
+					settled = true;
+					cleanup();
+					resolve(createFetchResponse(res.data, res.statusCode, toHeaderMap(res.header), meta.url));
+				},
+				fail: (err) => {
+					if (settled) return;
+					settled = true;
+					cleanup();
+					if (aborted) {
+						reject(createAbortError());
+						return;
+					}
+					const message = isObject(err) && typeof err.errMsg === "string" ? err.errMsg : String(err);
+					reject(new TypeError(message));
+				}
+			});
+			const requestTask = isRequestTask(requestResult) ? requestResult : void 0;
+		});
+	});
+}
+//#endregion
+export { fetch };

package/dist/index-Ciz2Ye1L.d.mts

@@ -0,0 +1,246 @@
+import { AllowedComponentProps, ComponentCustomProps, ComponentOptionsMixin, ComputedOptions, DefineComponent, EmitsOptions, MethodOptions, ObjectDirective, PublicProps, Ref, ShallowRef, ShallowUnwrapRef, SlotsType, VNode, VNodeProps } from "vue";
+
+//#region src/runtime/types/props/propTypes.d.ts
+type PropMethod<T, TConstructor = any> = [T] extends [((...args: any) => any) | undefined] ? {
+  new (): TConstructor;
+  (): T;
+  readonly prototype: TConstructor;
+} : never;
+type PropConstructor<T = any> = {
+  new (...args: any[]): T & {};
+} | {
+  (): T;
+} | PropMethod<T>;
+type PropType<T> = PropConstructor<T> | (PropConstructor<T> | null)[];
+type Prop<T, D = T> = PropOptions<T, D> | PropType<T>;
+type ComponentPropsOptions = Record<string, PropOptions<any> | PropType<any> | null>;
+interface NativeTypeHint<T = any> {
+  readonly __wevuNativeType?: T;
+}
+type NativePropsOptions = Record<string, WechatMiniprogram.Component.AllProperty | NativeTypeHint<any>>;
+type NativePropType<T = any, C extends WechatMiniprogram.Component.ShortProperty = StringConstructor> = C & NativeTypeHint<T>;
+type NativeTypedProperty<T = any, P extends WechatMiniprogram.Component.AllProperty = WechatMiniprogram.Component.AllProperty> = P & NativeTypeHint<T>;
+interface PropOptions<T = any, D = T> {
+  type?: PropType<T> | true | null;
+  optionalTypes?: Array<WechatMiniprogram.Component.ShortProperty | PropConstructor<any>>;
+  /**
+   * 默认值（对齐 Vue 的 `default`；会被赋给小程序 property 的 `value`）
+   */
+  default?: D | (() => D);
+  /**
+   * 小程序 `value` 的别名
+   */
+  value?: D | (() => D);
+  observer?: string | ((newVal: T, oldVal: T, changedPath: Array<string | number>) => void);
+  required?: boolean;
+}
+type HasDefault<T> = T extends {
+  default: infer D;
+} ? D extends (() => undefined) | undefined ? false : true : T extends {
+  value: infer V;
+} ? V extends (() => undefined) | undefined ? false : true : false;
+type IsBooleanProp<T> = T extends {
+  type?: infer U;
+} ? IsBooleanProp<U> : T extends readonly any[] ? true extends IsBooleanProp<T[number]> ? true : false : T extends BooleanConstructor ? true : false;
+type RequiredKeys<T> = { [K in keyof T]: T[K] extends {
+  required: true;
+} ? K : HasDefault<T[K]> extends true ? K : IsBooleanProp<T[K]> extends true ? K : never }[keyof T];
+type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
+type DefaultKeys<T> = { [K in keyof T]: HasDefault<T[K]> extends true ? K : IsBooleanProp<T[K]> extends true ? K : never }[keyof T];
+type IfAny<T, Y, N> = 0 extends (1 & T) ? Y : N;
+type InferPropType<O, NullAsAny = true> = [O] extends [null] ? NullAsAny extends true ? any : null : [O] extends [{
+  type: null | true;
+}] ? any : [O] extends [ObjectConstructor | {
+  type: ObjectConstructor;
+}] ? Record<string, any> : [O] extends [BooleanConstructor | {
+  type: BooleanConstructor;
+}] ? boolean : [O] extends [DateConstructor | {
+  type: DateConstructor;
+}] ? Date : [O] extends [(infer U)[] | {
+  type: (infer U)[];
+}] ? U extends DateConstructor ? Date | InferPropType<U, false> : InferPropType<U, false> : [O] extends [Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? IfAny<V, V, D> : V : V : O;
+type IsUnion<T, U = T> = T extends any ? ([U] extends [T] ? false : true) : never;
+type WidenLiteral<T> = T extends string ? string extends T ? string : IsUnion<T> extends true ? T : string : T extends number ? number extends T ? number : IsUnion<T> extends true ? T : number : T extends boolean ? boolean extends T ? boolean : IsUnion<T> extends true ? T : boolean : T;
+type NativeInferByCtor<C> = C extends readonly any[] ? NativeInferByCtor<C[number]> : C extends StringConstructor ? string : C extends NumberConstructor ? number : C extends BooleanConstructor ? boolean : C extends DateConstructor ? Date : C extends ArrayConstructor ? any[] : C extends ObjectConstructor ? Record<string, any> : C extends null ? any : C extends PropConstructor<infer V> ? V : any;
+type MergeNativeType<Base, V> = Base extends string ? Exclude<Extract<WidenLiteral<V>, string>, never> | (Extract<WidenLiteral<V>, string> extends never ? string : never) : Base extends number ? Exclude<Extract<WidenLiteral<V>, number>, never> | (Extract<WidenLiteral<V>, number> extends never ? number : never) : Base extends boolean ? Exclude<Extract<WidenLiteral<V>, boolean>, never> | (Extract<WidenLiteral<V>, boolean> extends never ? boolean : never) : Base;
+type InferNativeByOption<O extends {
+  type?: any;
+}> = O['type'] extends NativeTypeHint<infer THint> ? THint : O extends {
+  value: infer V;
+} ? MergeNativeType<NativeInferByCtor<O['type']>, V> : NativeInferByCtor<O['type']>;
+type InferNativePropType<O> = O extends NativeTypeHint<infer T> ? T : O extends {
+  type?: any;
+} ? InferNativeByOption<O> : NativeInferByCtor<O>;
+type InferNativeProps<P extends NativePropsOptions = NativePropsOptions> = { readonly [K in keyof P]?: InferNativePropType<P[K]> };
+type InferProps<P extends ComponentPropsOptions = ComponentPropsOptions> = { [K in keyof Pick<P, RequiredKeys<P>>]: HasDefault<P[K]> extends true ? Exclude<InferPropType<P[K]>, undefined> : InferPropType<P[K]> } & { [K in keyof Pick<P, OptionalKeys<P>>]?: InferPropType<P[K]> };
+type ExtractPropTypes<P extends ComponentPropsOptions = ComponentPropsOptions> = InferProps<P>;
+type ExtractPublicPropTypes<P extends ComponentPropsOptions = ComponentPropsOptions> = InferProps<P>;
+type ExtractDefaultPropTypes<P extends ComponentPropsOptions = ComponentPropsOptions> = { [K in keyof Pick<P, DefaultKeys<P>>]: InferPropType<P[K]> };
+//#endregion
+//#region src/reactivity/ref.d.ts
+type Ref$2<T = any, S = T> = Ref$1<T, S>;
+type ShallowRef$2<T = any> = ShallowRef$1<T>;
+type MaybeRef<T = any> = T | Ref$2<T> | ShallowRef$2<T> | WritableComputedRef<T>;
+type MaybeRefOrGetter<T = any> = MaybeRef<T> | ComputedRef<T> | (() => T);
+declare function isRef(value: unknown): value is Ref$2<any>;
+declare function ref<T = any>(): Ref$2<T | undefined>;
+declare function ref<T>(value: T): Ref$2<T>;
+declare function unref<T>(value: MaybeRef<T> | ComputedRef<T>): T;
+declare function toValue<T>(source: MaybeRefOrGetter<T>): T;
+/**
+ * 自定义 ref 工厂：用于创建可显式控制 track/trigger 的自定义 ref
+ */
+type CustomRefFactory<T> = (track: () => void, trigger: () => void) => {
+  get: () => T;
+  set: (value: T) => void;
+};
+interface CustomRefOptions<T> {
+  get: () => T;
+  set: (value: T) => void;
+}
+type CustomRefSource<T> = CustomRefFactory<T> | CustomRefOptions<T>;
+declare function customRef<T>(factory: CustomRefSource<T>, defaultValue?: T): Ref$2<T>;
+//#endregion
+//#region src/reactivity/computed.d.ts
+type ComputedGetter<T> = () => T;
+type ComputedSetter<T> = (value: T) => void;
+interface BaseComputedRef<T, S = T> extends Ref$2<T, S> {
+  [key: symbol]: any;
+}
+interface ComputedRef<T = any> extends BaseComputedRef<T> {
+  readonly value: T;
+}
+interface WritableComputedRef<T, S = T> extends BaseComputedRef<T, S> {
+  value: T;
+}
+interface WritableComputedOptions<T> {
+  get: ComputedGetter<T>;
+  set: ComputedSetter<T>;
+}
+declare function computed<T>(getter: ComputedGetter<T>): ComputedRef<T>;
+declare function computed<T>(options: WritableComputedOptions<T>): WritableComputedRef<T>;
+//#endregion
+//#region src/vue-types.d.ts
+type Ref$1<T = any, S = T> = Ref<T, S>;
+type ShallowRef$1<T = any, S = T> = ShallowRef<T, S>;
+type AllowedComponentProps$1 = AllowedComponentProps;
+type ComponentCustomProps$1 = ComponentCustomProps;
+type ComponentOptionsMixin$1 = ComponentOptionsMixin;
+type DefineComponent$1<PropsOrPropOptions = ComponentPropsOptions, RawBindings = Record<string, any>, D = Record<string, any>, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = EmitsOptions, EE extends string = string, PP = PublicProps, Props = (PropsOrPropOptions extends ComponentPropsOptions ? ExtractPropTypes<PropsOrPropOptions> : PropsOrPropOptions), Defaults = (PropsOrPropOptions extends ComponentPropsOptions ? ExtractDefaultPropTypes<PropsOrPropOptions> : {}), S extends SlotsType = SlotsType> = DefineComponent<PropsOrPropOptions, RawBindings, D, C, M, Mixin, Extends, E, EE, PP, Props, Defaults, S>;
+type NativeComponent<Props = Record<string, any>> = new (...args: any[]) => InstanceType<DefineComponent$1<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Props, {}>>;
+type ObjectDirective$1<HostElement = any, Value = any, Modifiers extends string = string, Arg = any> = ObjectDirective<HostElement, Value, Modifiers, Arg>;
+type PublicProps$1 = PublicProps;
+type ShallowUnwrapRef$1<T> = ShallowUnwrapRef<T>;
+type VNode$1<HostNode = any, HostElement = any, ExtraProps = Record<string, any>> = VNode<HostNode, HostElement, ExtraProps>;
+type VNodeProps$1 = VNodeProps;
+//#endregion
+//#region src/store/types.d.ts
+/**
+ * @description Store 变更类型
+ */
+type MutationType = 'patch object' | 'patch function' | 'direct';
+/**
+ * @description Store 订阅回调签名
+ */
+interface SubscriptionCallback<S = any> {
+  (mutation: {
+    type: MutationType;
+    storeId: string;
+  }, state: S): void;
+}
+/**
+ * @description Store 订阅选项
+ */
+interface StoreSubscribeOptions {
+  /**
+   * @description 是否在卸载后仍保留订阅（适用于跨页面生命周期的订阅）
+   */
+  detached?: boolean;
+}
+/**
+ * @description Action 订阅回调上下文
+ */
+interface ActionContext<TStore = any> {
+  name: string;
+  store: TStore;
+  args: any[];
+  after: (cb: (result: any) => void) => void;
+  onError: (cb: (error: any) => void) => void;
+}
+/**
+ * @description Action 订阅回调类型
+ */
+interface ActionSubscriber<TStore = any> {
+  (context: ActionContext<TStore>): void;
+}
+/**
+ * @description Store 管理器（插件与共享实例）
+ */
+interface StoreManager {
+  install: (app: any) => void;
+  _stores: Map<string, any>;
+  use: (plugin: (context: {
+    store: any;
+  }) => void) => StoreManager;
+  _plugins: Array<(context: {
+    store: any;
+  }) => void>;
+}
+/**
+ * @description Getter 定义集合
+ */
+type GetterTree<S extends Record<string, any>> = Record<string, (state: S) => any>;
+/**
+ * @description 从 Getter 定义中推导返回类型
+ */
+type StoreGetters<G extends GetterTree<any>> = { [K in keyof G]: G[K] extends ((...args: any[]) => infer R) ? R : never };
+/**
+ * @description defineStore(options) 的配置类型
+ */
+interface DefineStoreOptions<S extends Record<string, any>, G extends GetterTree<S>, A extends Record<string, any>> {
+  state: () => S;
+  getters?: G & Record<string, (state: S) => any> & ThisType<S & StoreGetters<G> & A>;
+  actions?: A & ThisType<S & StoreGetters<G> & A>;
+}
+//#endregion
+//#region src/store/define.d.ts
+type SetupDefinition<T> = () => T;
+/**
+ * @description 定义一个 setup 风格的 store
+ */
+declare function defineStore<T extends Record<string, any>>(id: string, setup: SetupDefinition<T>): () => T & {
+  $id: string;
+  $patch: (patch: Record<string, any> | ((state: any) => void)) => void;
+  $reset: () => void;
+  $subscribe: (cb: SubscriptionCallback<any>, opts?: StoreSubscribeOptions) => () => void;
+  $onAction: (cb: ActionSubscriber<any>) => () => void;
+};
+/**
+ * @description 定义一个 options 风格的 store
+ */
+declare function defineStore<S extends Record<string, any>, G extends Record<string, any>, A extends Record<string, any>>(id: string, options: DefineStoreOptions<S, G, A>): () => S & StoreGetters<G> & A & {
+  $id: string;
+  $state: S;
+  $patch: (patch: Partial<S> | ((state: S) => void)) => void;
+  $reset: () => void;
+  $subscribe: (cb: SubscriptionCallback<S>, opts?: StoreSubscribeOptions) => () => void;
+  $onAction: (cb: ActionSubscriber<S & StoreGetters<G> & A>) => () => void;
+};
+//#endregion
+//#region src/store/manager.d.ts
+/**
+ * @description 创建 store 管理器（插件与共享实例入口）
+ */
+declare function createStore(): StoreManager;
+//#endregion
+//#region src/store/storeToRefs.d.ts
+/**
+ * @description storeToRefs 返回类型推导
+ */
+type StoreToRefsResult<T extends Record<string, any>> = { [K in keyof T]: T[K] extends ((...args: any[]) => any) ? T[K] : T[K] extends Ref$2<infer V> ? Ref$2<V> : Ref$2<T[K]> };
+/**
+ * @description 将 store 状态转换为 Ref
+ */
+declare function storeToRefs<T extends Record<string, any>>(store: T): StoreToRefsResult<T>;
+//#endregion
+export { PropOptions as $, CustomRefSource as A, ComponentPropsOptions as B, ComputedRef as C, computed as D, WritableComputedRef as E, customRef as F, InferNativeProps as G, ExtractPropTypes as H, isRef as I, NativePropType as J, InferPropType as K, ref as L, MaybeRefOrGetter as M, Ref$2 as N, CustomRefFactory as O, ShallowRef$2 as P, PropConstructor as Q, toValue as R, ComputedGetter as S, WritableComputedOptions as T, ExtractPublicPropTypes as U, ExtractDefaultPropTypes as V, InferNativePropType as W, NativeTypeHint as X, NativePropsOptions as Y, NativeTypedProperty as Z, ObjectDirective$1 as _, ActionContext as a, VNode$1 as b, MutationType as c, SubscriptionCallback as d, PropType as et, AllowedComponentProps$1 as f, NativeComponent as g, DefineComponent$1 as h, defineStore as i, MaybeRef as j, CustomRefOptions as k, StoreManager as l, ComponentOptionsMixin$1 as m, storeToRefs as n, ActionSubscriber as o, ComponentCustomProps$1 as p, InferProps as q, createStore as r, DefineStoreOptions as s, StoreToRefsResult as t, StoreSubscribeOptions as u, PublicProps$1 as v, ComputedSetter as w, VNodeProps$1 as x, ShallowUnwrapRef$1 as y, unref as z };