@coaction/solid 1.4.1 → 2.0.0

package/README.md

@@ -1,6 +1,6 @@
 # @coaction/solid
 
-![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/solid.svg)](https://www.npmjs.com/package/@coaction/solid)
 ![license](https://img.shields.io/npm/l/@coaction/solid)
 
@@ -34,4 +34,4 @@ console.log(count());
 
 ## 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 { Accessor } from 'solid-js';
+import { Asyncify, ClientStoreOptions, ISlices, Slice, SliceState, Store, StoreOptions } from "coaction";
+import { Accessor } from "solid-js";
+export * from "coaction";
 
+//#region \0rolldown/runtime.js
+//#endregion
+//#region packages/coaction-solid/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[] ? Accessor<T[K]> : T[K] extends object ? AutoSelector<T[K]> : Accessor<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[] ? Accessor<T> : T extends LeafObject ? Accessor<T> : T extends object ? AutoSelector<T> : Accessor<T>;
+type AutoSelector<T> = { [K in keyof T]: AutoSelectorValue<T[K]> };
 type StoreReturn<T extends object> = Store<T> & {
-    <P>(selector: (state: T) => P): Accessor<P>;
-    (options: {
-        autoSelector: true;
-    }): AutoSelector<T>;
-    (options?: SelectorOptions): Accessor<T>;
+  <P>(selector: (state: T) => P): Accessor<P>;
+  (options: {
+    autoSelector: true;
+  }): AutoSelector<T>;
+  (options?: SelectorOptions): Accessor<T>;
 };
 type StoreWithAsyncFunction<T extends object, D extends true | false = false> = Store<Asyncify<T, D>> & {
-    <P>(selector: (state: Asyncify<T, D>) => P): Accessor<P>;
-    (options: {
-        autoSelector: true;
-    }): AutoSelector<Asyncify<T, D>>;
-    (options?: SelectorOptions): Accessor<Asyncify<T, D>>;
+  <P>(selector: (state: Asyncify<T, D>) => P): Accessor<P>;
+  (options: {
+    autoSelector: true;
+  }): AutoSelector<Asyncify<T, D>>;
+  (options?: SelectorOptions): Accessor<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 { Accessor } from 'solid-js';
+import { Asyncify, ClientStoreOptions, ISlices, Slice, SliceState, Store, StoreOptions } from "coaction";
+import { Accessor } from "solid-js";
+export * from "coaction";
 
+//#region \0rolldown/runtime.js
+//#endregion
+//#region packages/coaction-solid/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[] ? Accessor<T[K]> : T[K] extends object ? AutoSelector<T[K]> : Accessor<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[] ? Accessor<T> : T extends LeafObject ? Accessor<T> : T extends object ? AutoSelector<T> : Accessor<T>;
+type AutoSelector<T> = { [K in keyof T]: AutoSelectorValue<T[K]> };
 type StoreReturn<T extends object> = Store<T> & {
-    <P>(selector: (state: T) => P): Accessor<P>;
-    (options: {
-        autoSelector: true;
-    }): AutoSelector<T>;
-    (options?: SelectorOptions): Accessor<T>;
+  <P>(selector: (state: T) => P): Accessor<P>;
+  (options: {
+    autoSelector: true;
+  }): AutoSelector<T>;
+  (options?: SelectorOptions): Accessor<T>;
 };
 type StoreWithAsyncFunction<T extends object, D extends true | false = false> = Store<Asyncify<T, D>> & {
-    <P>(selector: (state: Asyncify<T, D>) => P): Accessor<P>;
-    (options: {
-        autoSelector: true;
-    }): AutoSelector<Asyncify<T, D>>;
-    (options?: SelectorOptions): Accessor<Asyncify<T, D>>;
+  <P>(selector: (state: Asyncify<T, D>) => P): Accessor<P>;
+  (options: {
+    autoSelector: true;
+  }): AutoSelector<Asyncify<T, D>>;
+  (options?: SelectorOptions): Accessor<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,116 +1,94 @@
-"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 solid_js = require("solid-js");
+//#region packages/coaction-solid/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;
+const createAutoSelector = (store, getVersion) => {
+	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 () => {
+			getVersion();
+			return getPathValue(path);
+		};
+		if (ancestors.includes(value)) return () => {
+			getVersion();
+			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 __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_solid_js = require("solid-js");
-__reExport(src_exports, require("coaction"));
-var createAutoSelector = (store, getVersion) => {
-  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] = () => {
-          getVersion();
-          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] = () => {
-          getVersion();
-          return store.getState()[sliceKey][key];
-        };
-      }
-    }
-    autoSelector[sliceKey] = sliceAutoSelector;
-  }
-  return autoSelector;
-};
-var create = (createState, options) => {
-  const store = (0, import_coaction.create)(createState, options);
-  const [version, setVersion] = (0, import_solid_js.createSignal)(0, {
-    equals: false
-  });
-  const unsubscribe = store.subscribe(() => {
-    setVersion((value) => value + 1);
-  });
-  const baseDestroy = store.destroy;
-  store.destroy = () => {
-    unsubscribe();
-    baseDestroy();
-  };
-  let autoSelector;
-  return (0, import_coaction.wrapStore)(store, (selector) => {
-    if (typeof selector === "function") {
-      return () => {
-        version();
-        return selector(store.getState());
-      };
-    }
-    if (selector?.autoSelector) {
-      if (!autoSelector) {
-        autoSelector = createAutoSelector(store, version);
-      }
-      return autoSelector;
-    }
-    return () => {
-      version();
-      return store.getState();
-    };
-  });
+const create = (createState, options) => {
+	const store = (0, coaction.create)(createState, options);
+	const [version, setVersion] = (0, solid_js.createSignal)(0, { equals: false });
+	const unsubscribe = store.subscribe(() => {
+		setVersion((value) => value + 1);
+	});
+	const baseDestroy = store.destroy;
+	let destroyed = false;
+	store.destroy = () => {
+		if (destroyed) return;
+		destroyed = true;
+		unsubscribe();
+		baseDestroy();
+	};
+	let autoSelector;
+	return (0, coaction.wrapStore)(store, (selector) => {
+		if (typeof selector === "function") return () => {
+			version();
+			return selector(store.getState());
+		};
+		if (selector?.autoSelector) {
+			if (!autoSelector) autoSelector = createAutoSelector(store, version);
+			return autoSelector;
+		}
+		return () => {
+			version();
+			return store.getState();
+		};
+	});
 };
-
-// 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,113 +1,86 @@
-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 { createSignal } from "solid-js";
-import * as coaction_star from "coaction";
-var createAutoSelector = (store, getVersion) => {
-  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] = () => {
-          getVersion();
-          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] = () => {
-          getVersion();
-          return store.getState()[sliceKey][key];
-        };
-      }
-    }
-    autoSelector[sliceKey] = sliceAutoSelector;
-  }
-  return autoSelector;
+export * from "coaction";
+//#endregion
+//#region packages/coaction-solid/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, setVersion] = createSignal(0, {
-    equals: false
-  });
-  const unsubscribe = store.subscribe(() => {
-    setVersion((value) => value + 1);
-  });
-  const baseDestroy = store.destroy;
-  store.destroy = () => {
-    unsubscribe();
-    baseDestroy();
-  };
-  let autoSelector;
-  return wrapStore(store, (selector) => {
-    if (typeof selector === "function") {
-      return () => {
-        version();
-        return selector(store.getState());
-      };
-    }
-    if (selector?.autoSelector) {
-      if (!autoSelector) {
-        autoSelector = createAutoSelector(store, version);
-      }
-      return autoSelector;
-    }
-    return () => {
-      version();
-      return store.getState();
-    };
-  });
+const createAutoSelector = (store, getVersion) => {
+	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 () => {
+			getVersion();
+			return getPathValue(path);
+		};
+		if (ancestors.includes(value)) return () => {
+			getVersion();
+			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, setVersion] = createSignal(0, { equals: false });
+	const unsubscribe = store.subscribe(() => {
+		setVersion((value) => value + 1);
+	});
+	const baseDestroy = store.destroy;
+	let destroyed = false;
+	store.destroy = () => {
+		if (destroyed) return;
+		destroyed = true;
+		unsubscribe();
+		baseDestroy();
+	};
+	let autoSelector;
+	return wrapStore(store, (selector) => {
+		if (typeof selector === "function") return () => {
+			version();
+			return selector(store.getState());
+		};
+		if (selector?.autoSelector) {
+			if (!autoSelector) autoSelector = createAutoSelector(store, version);
+			return autoSelector;
+		}
+		return () => {
+			version();
+			return store.getState();
+		};
+	});
 };
+//#endregion
+export { create };

package/package.json

@@ -1,20 +1,31 @@
 {
   "name": "@coaction/solid",
-  "version": "1.4.1",
+  "version": "2.0.0",
   "description": "A Coaction integration tool for Solid",
   "keywords": [
-    "state",
     "coaction",
+    "signals",
     "solid",
-    "signals"
+    "state"
   ],
-  "authors": [
-    "Michael Lin <unadlib@gmail.com> (https://github.com/unadlib)"
-  ],
-  "homepage": "https://github.com/unadlib/coaction/tree/main/packages/coaction-solid#readme",
+  "homepage": "https://github.com/coactionjs/coaction/tree/main/packages/coaction-solid#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-solid"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
   "main": "dist/index.js",
   "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -24,44 +35,25 @@
     },
     "./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-solid"
-  },
-  "bugs": {
-    "url": "https://github.com/unadlib/coaction/issues"
-  },
-  "peerDependencies": {
-    "coaction": "^1.4.1",
-    "solid-js": "^1.8.0"
-  },
-  "peerDependenciesMeta": {
-    "coaction": {
-      "optional": true
-    },
-    "solid-js": {
-      "optional": true
-    }
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
   },
   "devDependencies": {
     "solid-js": "^1.9.10",
-    "coaction": "1.4.1"
+    "coaction": "2.0.0"
   },
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
+  "peerDependencies": {
+    "coaction": "^2.0.0",
+    "solid-js": "^1.8.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"
   }
 }