@coaction/vue 1.5.0 → 2.0.0

package/README.md

@@ -1,6 +1,6 @@
 # @coaction/vue
 
-![Node CI](https://github.com/unadlib/coaction/workflows/Node%20CI/badge.svg)
+![Node CI](https://github.com/coactionjs/coaction/workflows/Node%20CI/badge.svg)
 [![npm](https://img.shields.io/npm/v/@coaction/vue.svg)](https://www.npmjs.com/package/@coaction/vue)
 ![license](https://img.shields.io/npm/l/@coaction/vue)
 
@@ -50,4 +50,4 @@ console.log(selectors.count.value);
 
 ## Documentation
 
-You can find the documentation [here](https://github.com/unadlib/coaction).
+You can find the documentation [here](https://github.com/coactionjs/coaction).

package/dist/index.d.mts

@@ -1,34 +1,48 @@
-import { ISlices, Slice, StoreOptions, Store, SliceState, ClientStoreOptions, Asyncify } from 'coaction';
-export * from 'coaction';
-import { ComputedRef } from 'vue';
+import { Asyncify, ClientStoreOptions, ISlices, Slice, SliceState, Store, StoreOptions } from "coaction";
+import { ComputedRef } from "vue";
+export * from "coaction";
 
+//#region \0rolldown/runtime.js
+//#endregion
+//#region packages/coaction-vue/src/index.d.ts
 type SelectorOptions = {
-    autoSelector?: boolean;
-};
-type AutoSelector<T> = {
-    [K in keyof T]: T[K] extends (...args: any[]) => any ? T[K] : T[K] extends readonly any[] ? ComputedRef<T[K]> : T[K] extends object ? AutoSelector<T[K]> : ComputedRef<T[K]>;
+  autoSelector?: boolean;
 };
+type LeafObject = Date | RegExp | Error | Promise<unknown> | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | WeakMap<object, unknown> | WeakSet<object> | ArrayBuffer | DataView;
+type AutoSelectorValue<T> = T extends ((...args: any[]) => any) ? T : T extends readonly any[] ? ComputedRef<T> : T extends LeafObject ? ComputedRef<T> : T extends object ? AutoSelector<T> : ComputedRef<T>;
+type AutoSelector<T> = { [K in keyof T]: AutoSelectorValue<T[K]> };
 type StoreReturn<T extends object> = Store<T> & {
-    <P>(selector: (state: T) => P): ComputedRef<P>;
-    (options: {
-        autoSelector: true;
-    }): AutoSelector<T>;
-    (options?: SelectorOptions): T;
+  <P>(selector: (state: T) => P): ComputedRef<P>;
+  (options: {
+    autoSelector: true;
+  }): AutoSelector<T>;
+  (options?: SelectorOptions): T;
 };
 type StoreWithAsyncFunction<T extends object, D extends true | false = false> = Store<Asyncify<T, D>> & {
-    <P>(selector: (state: Asyncify<T, D>) => P): ComputedRef<P>;
-    (options: {
-        autoSelector: true;
-    }): AutoSelector<Asyncify<T, D>>;
-    (options?: SelectorOptions): Asyncify<T, D>;
+  <P>(selector: (state: Asyncify<T, D>) => P): ComputedRef<P>;
+  (options: {
+    autoSelector: true;
+  }): AutoSelector<Asyncify<T, D>>;
+  (options?: SelectorOptions): Asyncify<T, D>;
+};
+type CreateState = ISlices | Record<PropertyKey, Slice<any>>;
+type SingleStoreOptions<T extends CreateState> = StoreOptions<T> & {
+  sliceMode: 'single';
+};
+type SingleClientStoreOptions<T extends CreateState> = ClientStoreOptions<T> & {
+  sliceMode: 'single';
 };
-type CreateState = ISlices | Record<string, Slice<any>>;
 type Creator = {
-    <T extends Record<string, Slice<any>>>(createState: T, options?: StoreOptions<T>): StoreReturn<SliceState<T>>;
-    <T extends ISlices>(createState: Slice<T>, options?: StoreOptions<T>): StoreReturn<T>;
-    <T extends Record<string, Slice<any>>>(createState: T, options?: ClientStoreOptions<T>): StoreWithAsyncFunction<SliceState<T>, true>;
-    <T extends ISlices>(createState: Slice<T>, options?: ClientStoreOptions<T>): StoreWithAsyncFunction<T>;
+  <T extends ISlices>(createState: T, options: SingleStoreOptions<T>): StoreReturn<T>;
+  <T extends Record<PropertyKey, Slice<any>>>(createState: T, options?: StoreOptions<T>): StoreReturn<SliceState<T>>;
+  <T extends ISlices>(createState: Slice<T> | T, options?: StoreOptions<T>): StoreReturn<T>;
+  <T extends ISlices>(createState: T, options: SingleClientStoreOptions<T>): StoreWithAsyncFunction<T>;
+  <T extends Record<PropertyKey, Slice<any>>>(createState: T, options?: ClientStoreOptions<T>): StoreWithAsyncFunction<SliceState<T>, true>;
+  <T extends ISlices>(createState: Slice<T> | T, options?: ClientStoreOptions<T>): StoreWithAsyncFunction<T>;
 };
 declare const create: Creator;
-
-export { type CreateState, type Creator, type StoreReturn, type StoreWithAsyncFunction, create };
+declare namespace index_d_exports {
+  export { CreateState, Creator, StoreReturn, StoreWithAsyncFunction, create };
+}
+//#endregion
+export { CreateState, Creator, StoreReturn, StoreWithAsyncFunction, create };

package/dist/index.d.ts

@@ -1,34 +1,48 @@
-import { ISlices, Slice, StoreOptions, Store, SliceState, ClientStoreOptions, Asyncify } from 'coaction';
-export * from 'coaction';
-import { ComputedRef } from 'vue';
+import { Asyncify, ClientStoreOptions, ISlices, Slice, SliceState, Store, StoreOptions } from "coaction";
+import { ComputedRef } from "vue";
+export * from "coaction";
 
+//#region \0rolldown/runtime.js
+//#endregion
+//#region packages/coaction-vue/src/index.d.ts
 type SelectorOptions = {
-    autoSelector?: boolean;
-};
-type AutoSelector<T> = {
-    [K in keyof T]: T[K] extends (...args: any[]) => any ? T[K] : T[K] extends readonly any[] ? ComputedRef<T[K]> : T[K] extends object ? AutoSelector<T[K]> : ComputedRef<T[K]>;
+  autoSelector?: boolean;
 };
+type LeafObject = Date | RegExp | Error | Promise<unknown> | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | WeakMap<object, unknown> | WeakSet<object> | ArrayBuffer | DataView;
+type AutoSelectorValue<T> = T extends ((...args: any[]) => any) ? T : T extends readonly any[] ? ComputedRef<T> : T extends LeafObject ? ComputedRef<T> : T extends object ? AutoSelector<T> : ComputedRef<T>;
+type AutoSelector<T> = { [K in keyof T]: AutoSelectorValue<T[K]> };
 type StoreReturn<T extends object> = Store<T> & {
-    <P>(selector: (state: T) => P): ComputedRef<P>;
-    (options: {
-        autoSelector: true;
-    }): AutoSelector<T>;
-    (options?: SelectorOptions): T;
+  <P>(selector: (state: T) => P): ComputedRef<P>;
+  (options: {
+    autoSelector: true;
+  }): AutoSelector<T>;
+  (options?: SelectorOptions): T;
 };
 type StoreWithAsyncFunction<T extends object, D extends true | false = false> = Store<Asyncify<T, D>> & {
-    <P>(selector: (state: Asyncify<T, D>) => P): ComputedRef<P>;
-    (options: {
-        autoSelector: true;
-    }): AutoSelector<Asyncify<T, D>>;
-    (options?: SelectorOptions): Asyncify<T, D>;
+  <P>(selector: (state: Asyncify<T, D>) => P): ComputedRef<P>;
+  (options: {
+    autoSelector: true;
+  }): AutoSelector<Asyncify<T, D>>;
+  (options?: SelectorOptions): Asyncify<T, D>;
+};
+type CreateState = ISlices | Record<PropertyKey, Slice<any>>;
+type SingleStoreOptions<T extends CreateState> = StoreOptions<T> & {
+  sliceMode: 'single';
+};
+type SingleClientStoreOptions<T extends CreateState> = ClientStoreOptions<T> & {
+  sliceMode: 'single';
 };
-type CreateState = ISlices | Record<string, Slice<any>>;
 type Creator = {
-    <T extends Record<string, Slice<any>>>(createState: T, options?: StoreOptions<T>): StoreReturn<SliceState<T>>;
-    <T extends ISlices>(createState: Slice<T>, options?: StoreOptions<T>): StoreReturn<T>;
-    <T extends Record<string, Slice<any>>>(createState: T, options?: ClientStoreOptions<T>): StoreWithAsyncFunction<SliceState<T>, true>;
-    <T extends ISlices>(createState: Slice<T>, options?: ClientStoreOptions<T>): StoreWithAsyncFunction<T>;
+  <T extends ISlices>(createState: T, options: SingleStoreOptions<T>): StoreReturn<T>;
+  <T extends Record<PropertyKey, Slice<any>>>(createState: T, options?: StoreOptions<T>): StoreReturn<SliceState<T>>;
+  <T extends ISlices>(createState: Slice<T> | T, options?: StoreOptions<T>): StoreReturn<T>;
+  <T extends ISlices>(createState: T, options: SingleClientStoreOptions<T>): StoreWithAsyncFunction<T>;
+  <T extends Record<PropertyKey, Slice<any>>>(createState: T, options?: ClientStoreOptions<T>): StoreWithAsyncFunction<SliceState<T>, true>;
+  <T extends ISlices>(createState: Slice<T> | T, options?: ClientStoreOptions<T>): StoreWithAsyncFunction<T>;
 };
 declare const create: Creator;
-
-export { type CreateState, type Creator, type StoreReturn, type StoreWithAsyncFunction, create };
+declare namespace index_d_exports {
+  export { CreateState, Creator, StoreReturn, StoreWithAsyncFunction, create };
+}
+//#endregion
+export { CreateState, Creator, StoreReturn, StoreWithAsyncFunction, create };

package/dist/index.js

@@ -1,143 +1,115 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#endregion
+let coaction = require("coaction");
+let vue = require("vue");
+//#region packages/coaction-vue/src/index.ts
+const getOwnEnumerableKeys = (value) => Reflect.ownKeys(value).filter((key) => Object.prototype.propertyIsEnumerable.call(value, key));
+const isPlainObject = (value) => {
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// index.ts
-var index_exports = {};
-__export(index_exports, {
-  create: () => create
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  create: () => create
-});
-var import_coaction = require("coaction");
-var import_vue = require("vue");
-__reExport(src_exports, require("coaction"));
-var createStateProxy = (store, version) => new Proxy({}, {
-  get(_, key) {
-    void version.value;
-    const state = store.getState();
-    const value = state[key];
-    if (typeof value === "function") {
-      return value.bind(store.getState());
-    }
-    return value;
-  },
-  has(_, key) {
-    void version.value;
-    return key in store.getState();
-  },
-  ownKeys() {
-    void version.value;
-    return Reflect.ownKeys(store.getState());
-  },
-  getOwnPropertyDescriptor(_, key) {
-    void version.value;
-    const descriptor = Object.getOwnPropertyDescriptor(store.getState(), key);
-    if (!descriptor) {
-      return void 0;
-    }
-    return {
-      ...descriptor,
-      configurable: true
-    };
-  }
+const createStateProxy = (store, version) => new Proxy({}, {
+	get(_, key) {
+		version.value;
+		return store.getState()[key];
+	},
+	has(_, key) {
+		version.value;
+		return key in store.getState();
+	},
+	ownKeys() {
+		version.value;
+		return Reflect.ownKeys(store.getState());
+	},
+	getOwnPropertyDescriptor(_, key) {
+		version.value;
+		const descriptor = Object.getOwnPropertyDescriptor(store.getState(), key);
+		if (!descriptor) return;
+		return {
+			...descriptor,
+			configurable: true
+		};
+	}
 });
-var createAutoSelector = (store, version) => {
-  const state = store.getState();
-  if (!store.isSliceStore) {
-    const autoSelector2 = {};
-    const descriptors = Object.getOwnPropertyDescriptors(state);
-    for (const key of Object.keys(descriptors)) {
-      const descriptor = descriptors[key];
-      if (typeof descriptor.value === "function") {
-        autoSelector2[key] = descriptor.value.bind(state);
-      } else {
-        autoSelector2[key] = (0, import_vue.computed)(() => {
-          void version.value;
-          return store.getState()[key];
-        });
-      }
-    }
-    return autoSelector2;
-  }
-  const autoSelector = {};
-  for (const sliceKey of Object.keys(state)) {
-    const slice = state[sliceKey];
-    if (typeof slice !== "object" || slice === null) {
-      continue;
-    }
-    const sliceAutoSelector = {};
-    const descriptors = Object.getOwnPropertyDescriptors(slice);
-    for (const key of Object.keys(descriptors)) {
-      const descriptor = descriptors[key];
-      if (typeof descriptor.value === "function") {
-        sliceAutoSelector[key] = descriptor.value.bind(slice);
-      } else {
-        sliceAutoSelector[key] = (0, import_vue.computed)(() => {
-          void version.value;
-          return store.getState()[sliceKey][key];
-        });
-      }
-    }
-    autoSelector[sliceKey] = sliceAutoSelector;
-  }
-  return autoSelector;
+const createAutoSelector = (store, version) => {
+	const getPathValue = (path) => {
+		let current = store.getState();
+		for (const key of path) {
+			if (typeof current !== "object" && typeof current !== "function" || current === null) return;
+			current = current[key];
+		}
+		return current;
+	};
+	const createAction = (path) => ((...args) => {
+		const fn = getPathValue(path);
+		if (typeof fn !== "function") return;
+		const receiverPath = path.slice(0, -1);
+		const receiver = receiverPath.length ? getPathValue(receiverPath) : store.getState();
+		return fn.apply(receiver, args);
+	});
+	const createNode = (path, value, ancestors = []) => {
+		if (typeof value === "function") return createAction(path);
+		if (typeof value !== "object" || value === null || Array.isArray(value) || !isPlainObject(value)) return (0, vue.computed)(() => {
+			version.value;
+			return getPathValue(path);
+		});
+		if (ancestors.includes(value)) return (0, vue.computed)(() => {
+			version.value;
+			return getPathValue(path);
+		});
+		const node = {};
+		const nextAncestors = [...ancestors, value];
+		for (const key of getOwnEnumerableKeys(value)) node[key] = createNode([...path, key], value[key], nextAncestors);
+		return node;
+	};
+	const state = store.getState();
+	const autoSelector = {};
+	if (!store.isSliceStore) {
+		for (const key of getOwnEnumerableKeys(state)) autoSelector[key] = createNode([key], state[key]);
+		return autoSelector;
+	}
+	for (const sliceKey of getOwnEnumerableKeys(state)) {
+		const slice = state[sliceKey];
+		if (typeof slice !== "object" || slice === null) continue;
+		autoSelector[sliceKey] = createNode([sliceKey], slice);
+	}
+	return autoSelector;
 };
-var create = (createState, options) => {
-  const store = (0, import_coaction.create)(createState, options);
-  const version = (0, import_vue.ref)(0);
-  const unsubscribe = store.subscribe(() => {
-    version.value += 1;
-  });
-  const baseDestroy = store.destroy;
-  store.destroy = () => {
-    unsubscribe();
-    baseDestroy();
-  };
-  const stateProxy = createStateProxy(store, version);
-  let autoSelector;
-  const useStore = (0, import_coaction.wrapStore)(store, (selector) => {
-    if (typeof selector === "function") {
-      return (0, import_vue.computed)(() => {
-        void version.value;
-        return selector(store.getState());
-      });
-    }
-    if (selector?.autoSelector) {
-      if (!autoSelector) {
-        autoSelector = createAutoSelector(store, version);
-      }
-      return autoSelector;
-    }
-    return stateProxy;
-  });
-  return useStore;
+const create = (createState, options) => {
+	const store = (0, coaction.create)(createState, options);
+	const version = (0, vue.ref)(0);
+	const unsubscribe = store.subscribe(() => {
+		version.value += 1;
+	});
+	const baseDestroy = store.destroy;
+	let destroyed = false;
+	store.destroy = () => {
+		if (destroyed) return;
+		destroyed = true;
+		unsubscribe();
+		baseDestroy();
+	};
+	const stateProxy = createStateProxy(store, version);
+	let autoSelector;
+	return (0, coaction.wrapStore)(store, (selector) => {
+		if (typeof selector === "function") return (0, vue.computed)(() => {
+			version.value;
+			return selector(store.getState());
+		});
+		if (selector?.autoSelector) {
+			if (!autoSelector) autoSelector = createAutoSelector(store, version);
+			return autoSelector;
+		}
+		return stateProxy;
+	});
 };
-
-// index.ts
-__reExport(index_exports, src_exports, module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  create
+//#endregion
+exports.create = create;
+Object.keys(coaction).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return coaction[k];
+		}
+	});
 });

package/dist/index.mjs

@@ -1,140 +1,107 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-
-// index.ts
-var index_exports = {};
-__export(index_exports, {
-  create: () => create
-});
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  create: () => create
-});
-__reExport(src_exports, coaction_star);
-import { create as createVanilla, wrapStore } from "coaction";
+import { create as create$1, wrapStore } from "coaction";
 import { computed, ref } from "vue";
-import * as coaction_star from "coaction";
-var createStateProxy = (store, version) => new Proxy({}, {
-  get(_, key) {
-    void version.value;
-    const state = store.getState();
-    const value = state[key];
-    if (typeof value === "function") {
-      return value.bind(store.getState());
-    }
-    return value;
-  },
-  has(_, key) {
-    void version.value;
-    return key in store.getState();
-  },
-  ownKeys() {
-    void version.value;
-    return Reflect.ownKeys(store.getState());
-  },
-  getOwnPropertyDescriptor(_, key) {
-    void version.value;
-    const descriptor = Object.getOwnPropertyDescriptor(store.getState(), key);
-    if (!descriptor) {
-      return void 0;
-    }
-    return {
-      ...descriptor,
-      configurable: true
-    };
-  }
-});
-var createAutoSelector = (store, version) => {
-  const state = store.getState();
-  if (!store.isSliceStore) {
-    const autoSelector2 = {};
-    const descriptors = Object.getOwnPropertyDescriptors(state);
-    for (const key of Object.keys(descriptors)) {
-      const descriptor = descriptors[key];
-      if (typeof descriptor.value === "function") {
-        autoSelector2[key] = descriptor.value.bind(state);
-      } else {
-        autoSelector2[key] = computed(() => {
-          void version.value;
-          return store.getState()[key];
-        });
-      }
-    }
-    return autoSelector2;
-  }
-  const autoSelector = {};
-  for (const sliceKey of Object.keys(state)) {
-    const slice = state[sliceKey];
-    if (typeof slice !== "object" || slice === null) {
-      continue;
-    }
-    const sliceAutoSelector = {};
-    const descriptors = Object.getOwnPropertyDescriptors(slice);
-    for (const key of Object.keys(descriptors)) {
-      const descriptor = descriptors[key];
-      if (typeof descriptor.value === "function") {
-        sliceAutoSelector[key] = descriptor.value.bind(slice);
-      } else {
-        sliceAutoSelector[key] = computed(() => {
-          void version.value;
-          return store.getState()[sliceKey][key];
-        });
-      }
-    }
-    autoSelector[sliceKey] = sliceAutoSelector;
-  }
-  return autoSelector;
+export * from "coaction";
+//#endregion
+//#region packages/coaction-vue/src/index.ts
+const getOwnEnumerableKeys = (value) => Reflect.ownKeys(value).filter((key) => Object.prototype.propertyIsEnumerable.call(value, key));
+const isPlainObject = (value) => {
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
 };
-var create = (createState, options) => {
-  const store = createVanilla(createState, options);
-  const version = ref(0);
-  const unsubscribe = store.subscribe(() => {
-    version.value += 1;
-  });
-  const baseDestroy = store.destroy;
-  store.destroy = () => {
-    unsubscribe();
-    baseDestroy();
-  };
-  const stateProxy = createStateProxy(store, version);
-  let autoSelector;
-  const useStore = wrapStore(store, (selector) => {
-    if (typeof selector === "function") {
-      return computed(() => {
-        void version.value;
-        return selector(store.getState());
-      });
-    }
-    if (selector?.autoSelector) {
-      if (!autoSelector) {
-        autoSelector = createAutoSelector(store, version);
-      }
-      return autoSelector;
-    }
-    return stateProxy;
-  });
-  return useStore;
+const createStateProxy = (store, version) => new Proxy({}, {
+	get(_, key) {
+		version.value;
+		return store.getState()[key];
+	},
+	has(_, key) {
+		version.value;
+		return key in store.getState();
+	},
+	ownKeys() {
+		version.value;
+		return Reflect.ownKeys(store.getState());
+	},
+	getOwnPropertyDescriptor(_, key) {
+		version.value;
+		const descriptor = Object.getOwnPropertyDescriptor(store.getState(), key);
+		if (!descriptor) return;
+		return {
+			...descriptor,
+			configurable: true
+		};
+	}
+});
+const createAutoSelector = (store, version) => {
+	const getPathValue = (path) => {
+		let current = store.getState();
+		for (const key of path) {
+			if (typeof current !== "object" && typeof current !== "function" || current === null) return;
+			current = current[key];
+		}
+		return current;
+	};
+	const createAction = (path) => ((...args) => {
+		const fn = getPathValue(path);
+		if (typeof fn !== "function") return;
+		const receiverPath = path.slice(0, -1);
+		const receiver = receiverPath.length ? getPathValue(receiverPath) : store.getState();
+		return fn.apply(receiver, args);
+	});
+	const createNode = (path, value, ancestors = []) => {
+		if (typeof value === "function") return createAction(path);
+		if (typeof value !== "object" || value === null || Array.isArray(value) || !isPlainObject(value)) return computed(() => {
+			version.value;
+			return getPathValue(path);
+		});
+		if (ancestors.includes(value)) return computed(() => {
+			version.value;
+			return getPathValue(path);
+		});
+		const node = {};
+		const nextAncestors = [...ancestors, value];
+		for (const key of getOwnEnumerableKeys(value)) node[key] = createNode([...path, key], value[key], nextAncestors);
+		return node;
+	};
+	const state = store.getState();
+	const autoSelector = {};
+	if (!store.isSliceStore) {
+		for (const key of getOwnEnumerableKeys(state)) autoSelector[key] = createNode([key], state[key]);
+		return autoSelector;
+	}
+	for (const sliceKey of getOwnEnumerableKeys(state)) {
+		const slice = state[sliceKey];
+		if (typeof slice !== "object" || slice === null) continue;
+		autoSelector[sliceKey] = createNode([sliceKey], slice);
+	}
+	return autoSelector;
 };
-
-// index.ts
-__reExport(index_exports, src_exports);
-export {
-  create
+const create = (createState, options) => {
+	const store = create$1(createState, options);
+	const version = ref(0);
+	const unsubscribe = store.subscribe(() => {
+		version.value += 1;
+	});
+	const baseDestroy = store.destroy;
+	let destroyed = false;
+	store.destroy = () => {
+		if (destroyed) return;
+		destroyed = true;
+		unsubscribe();
+		baseDestroy();
+	};
+	const stateProxy = createStateProxy(store, version);
+	let autoSelector;
+	return wrapStore(store, (selector) => {
+		if (typeof selector === "function") return computed(() => {
+			version.value;
+			return selector(store.getState());
+		});
+		if (selector?.autoSelector) {
+			if (!autoSelector) autoSelector = createAutoSelector(store, version);
+			return autoSelector;
+		}
+		return stateProxy;
+	});
 };
+//#endregion
+export { create };

package/package.json

@@ -1,21 +1,32 @@
 {
   "name": "@coaction/vue",
-  "version": "1.5.0",
+  "version": "2.0.0",
   "description": "A Coaction integration tool for Vue",
   "keywords": [
     "coaction",
-    "vue",
+    "data-transport",
     "multithreading",
     "mutative",
-    "data-transport"
+    "vue"
   ],
-  "authors": [
-    "Michael Lin <unadlib@gmail.com> (https://github.com/unadlib)"
-  ],
-  "homepage": "https://github.com/unadlib/coaction/tree/main/packages/coaction-vue#readme",
+  "homepage": "https://github.com/coactionjs/coaction/tree/main/packages/coaction-vue#readme",
+  "bugs": {
+    "url": "https://github.com/coactionjs/coaction/issues"
+  },
   "license": "MIT",
+  "author": "unadlib",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/coactionjs/coaction.git",
+    "directory": "packages/coaction-vue"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
   "main": "dist/index.js",
   "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -25,42 +36,26 @@
     },
     "./package.json": "./package.json"
   },
-  "types": "dist/index.d.ts",
-  "sideEffects": false,
-  "files": [
-    "dist"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/unadlib/coaction.git",
-    "directory": "packages/coaction-vue"
-  },
-  "bugs": {
-    "url": "https://github.com/unadlib/coaction/issues"
-  },
-  "peerDependencies": {
-    "coaction": "^1.5.0",
-    "vue": "^3.0.0"
-  },
-  "peerDependenciesMeta": {
-    "coaction": {
-      "optional": true
-    }
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
   },
   "devDependencies": {
     "@testing-library/vue": "^8.1.0",
     "vue": "^3.5.30",
-    "coaction": "1.5.0"
+    "coaction": "2.0.0"
   },
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
+  "peerDependencies": {
+    "coaction": "^2.0.0",
+    "vue": "^3.0.0"
   },
-  "author": "unadlib",
+  "authors": [
+    "Michael Lin <unadlib@gmail.com> (https://github.com/unadlib)"
+  ],
   "scripts": {
     "clean": "rm -rf dist",
     "test": "vitest run test",
-    "build": "tsup index.ts --format cjs,esm --dts --clean --out-dir dist",
-    "dev": "tsup index.ts --format cjs,esm --dts --watch --out-dir dist"
+    "build": "node ../../scripts/build-package.mjs",
+    "dev": "node ../../scripts/build-package.mjs --watch"
   }
 }