pinia-react 1.0.0 → 1.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 karl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+//#region src/types.d.ts
+
+type StateTree = Record<string | number | symbol, unknown>;
+type _StoreWithGetters<G> = { readonly [k in keyof G]: G[k] extends ((...args: any[]) => infer R) ? R : G[k] };
+type _ActionsTree = Record<string | number | symbol, (...args: any[]) => any>;
+type PiniaCustomStateProperties<S extends StateTree = StateTree> = {};
+type _GettersTree<S extends StateTree> = Record<string, (state: S & PiniaCustomStateProperties<S>) => any>;
+/**
+ * Interface to be extended by the user when they add properties through plugins.
+ */
+type PiniaCustomProperties<Id extends string = string, S extends StateTree = StateTree, G = _GettersTree<S>, A = _ActionsTree> = {};
+type _DeepPartial<T> = { [K in keyof T]?: _DeepPartial<T[K]> };
+interface _StoreWithState<Id extends string, S extends StateTree, G, A> {
+  $id: Id;
+  $state: S & PiniaCustomStateProperties<S>;
+  $patch(partialState: _DeepPartial<S>): void;
+  $patch<F extends (state: S) => any>(stateMutator: ReturnType<F> extends Promise<any> ? never : F): void;
+  $reset(): void;
+  $subscribe(callback: (newValue: S) => any, options?: {
+    detached: boolean;
+  }): any;
+}
+type Store<Id extends string, S extends StateTree, G, A> = _StoreWithState<Id, S, G, A> & S & _StoreWithGetters<G> & (_ActionsTree extends A ? {} : A) & PiniaCustomProperties<Id, S, G, A> & PiniaCustomStateProperties<S>;
+type StoreGeneric = Store<string, StateTree, _GettersTree<StateTree>, _ActionsTree>;
+type DefineStoreOptionsBase<S extends StateTree, Store> = {};
+interface DefineStoreOptions<Id extends string, S extends StateTree, G, A> extends DefineStoreOptionsBase<S, Store<Id, S, G, A>> {
+  state?: () => S;
+  getters?: G & ThisType<S & _StoreWithGetters<G> & PiniaCustomProperties>;
+  actions?: A & ThisType<A & S & _StoreWithState<Id, S, G, A> & _StoreWithGetters<G> & PiniaCustomProperties>;
+}
+/**
+ * Return type of `defineStore()`. Function that allows instantiating a store.
+ */
+interface StoreDefinition<Id extends string = string, S extends StateTree = StateTree, G = _GettersTree<S>, A = _ActionsTree> {
+  /**
+   * Returns a store, creates it if necessary.
+   */
+  (): Store<Id, S, G, A>;
+  /**
+   * Id of the store. Used by map helpers.
+   */
+  $id: Id;
+}
+type PiniaPluginContext<Id extends string = string, S extends StateTree = StateTree, G = _GettersTree<S>, A = _ActionsTree> = {
+  options: DefineStoreOptions<Id, S, G, A>;
+  store: Store<Id, S, G, A>;
+};
+type PiniaPlugin = (context: PiniaPluginContext) => Partial<PiniaCustomProperties & PiniaCustomStateProperties> | undefined;
+//#endregion
+//#region src/defineStore.d.ts
+declare function defineStore<Id extends string, S extends StateTree, G extends _GettersTree<S> = {}, A extends _ActionsTree = {}>(id: Id, options: DefineStoreOptions<Id, S, G, A>): StoreDefinition<Id, S, G, A>;
+//#endregion
+//#region src/pinia.d.ts
+interface Pinia {
+  _store: Map<string, StoreGeneric>;
+  _state: Map<string, StateTree>;
+  _plugins: Set<PiniaPlugin>;
+  use(plugin: PiniaPlugin): this;
+}
+declare let pinia: Pinia;
+declare function createPinia(): Pinia;
+declare function setActivePinia(_pinia: Pinia): void;
+//#endregion
+export { type DefineStoreOptionsBase, type PiniaCustomProperties, type PiniaCustomStateProperties, type PiniaPlugin, type PiniaPluginContext, type StateTree, type Store, createPinia, defineStore, pinia, setActivePinia };

package/dist/index.js

@@ -0,0 +1,157 @@
+import { ReactiveEffect, activeEffect, computed, isReactive, isRef, markRaw, reactive, toRefs, watch } from "@maoism/runtime-core";
+import React, { useCallback, useId, useRef } from "react";
+import { isFunction } from "savage-types";
+import "savage-utils";
+
+//#region src/pinia.ts
+let pinia;
+function createPinia() {
+	return {
+		_store: /* @__PURE__ */ new Map(),
+		_state: /* @__PURE__ */ new Map(),
+		_plugins: /* @__PURE__ */ new Set(),
+		use(p) {
+			this._plugins.add(p);
+			return this;
+		}
+	};
+}
+function setActivePinia(_pinia) {
+	pinia = _pinia;
+}
+setActivePinia(createPinia());
+
+//#endregion
+//#region src/utils.ts
+function noop() {
+	return {};
+}
+function isPlainObject(o) {
+	return o && typeof o === "object" && Object.prototype.toString.call(o) === "[object Object]" && typeof o.toJSON !== "function";
+}
+function mergeReactiveObjects(target, patchToApply) {
+	if (target instanceof Map && patchToApply instanceof Map) patchToApply.forEach((value, key) => target.set(key, value));
+	if (target instanceof Set && patchToApply instanceof Set) patchToApply.forEach(target.add, target);
+	for (const key in patchToApply) {
+		if (!Object.hasOwn(patchToApply, key)) continue;
+		const subPatch = patchToApply[key];
+		const targetValue = target[key];
+		if (isPlainObject(targetValue) && isPlainObject(subPatch) && target.hasOwnProperty(key) && !isRef(subPatch) && !isReactive(subPatch)) target[key] = mergeReactiveObjects(targetValue, subPatch);
+		else target[key] = subPatch;
+	}
+	return target;
+}
+
+//#endregion
+//#region src/subscription.ts
+const subscriptions = /* @__PURE__ */ new Set();
+function addSubscriptions(callback, onCleanup = noop) {
+	subscriptions.add(callback);
+	const remove = () => {
+		subscriptions.delete(callback);
+		onCleanup();
+	};
+	return remove;
+}
+function triggerSubscription(state) {
+	subscriptions.forEach((callback) => callback(state));
+}
+
+//#endregion
+//#region src/defineStore.ts
+let isLoadingPlugin = false;
+function defineStore(id, options) {
+	let isSyncListening = false;
+	function createStore() {
+		const { state, actions, getters } = options;
+		const $state = reactive(state ? state() : {});
+		const initState = state ? state() : {};
+		const baseStore = {
+			$id: id,
+			$state,
+			$patch(val) {
+				isSyncListening = false;
+				if (isFunction(val)) val($state);
+				else mergeReactiveObjects($state, val);
+				isSyncListening = true;
+				triggerSubscription($state);
+			},
+			$reset() {
+				this.$patch((v) => {
+					Object.assign(v, initState);
+				});
+			},
+			$subscribe(cb) {
+				const remove = addSubscriptions(cb, () => unwatch());
+				const unwatch = watch($state, (state$1) => {
+					if (isSyncListening) cb(state$1);
+				}, {
+					deep: true,
+					flush: "sync"
+				});
+				return remove;
+			}
+		};
+		pinia._state.set(id, $state);
+		const store = reactive(Object.assign(baseStore, toRefs($state), Object.keys(actions ?? []).reduce((x, y) => {
+			const key = y;
+			return Object.assign(x, { [key]: function(...args) {
+				return actions[key].call(this, ...args);
+			} });
+		}, {}), Object.keys(getters || {}).reduce((computedGetters, name) => {
+			computedGetters[name] = markRaw(computed(() => {
+				return getters?.[name].call(store, store);
+			}));
+			return computedGetters;
+		}, {})));
+		const lastLoadingPlugin = isLoadingPlugin;
+		isLoadingPlugin = true;
+		pinia._plugins.forEach((p) => {
+			Object.assign(store, p({
+				store,
+				options
+			}) || {});
+		});
+		isLoadingPlugin = lastLoadingPlugin;
+		pinia._store.set(id, store);
+	}
+	const effectMap = /* @__PURE__ */ new WeakMap();
+	const subscribeMap = /* @__PURE__ */ new WeakMap();
+	function useStore() {
+		if (!pinia._store.has(id)) createStore();
+		const store = pinia._store.get(id);
+		isSyncListening = true;
+		const _id = useRef([useId()]);
+		const storeSnapshotRef = React.useRef({ ...store });
+		const subscribe = useCallback((onStoreChange) => {
+			subscribeMap.set(_id.current, onStoreChange);
+			return () => {
+				const effect$1 = effectMap.get(_id.current);
+				if (effect$1) effect$1.stop();
+				subscribeMap.delete(_id.current);
+				effectMap.delete(_id.current);
+			};
+		}, []);
+		React.useSyncExternalStore(subscribe, () => storeSnapshotRef.current, () => ({ ...store }));
+		let effect = effectMap.get(_id.current);
+		if (!effect) {
+			const fn = () => {
+				const onStoreChange = subscribeMap.get(_id.current);
+				onStoreChange?.();
+			};
+			effect = new ReactiveEffect(fn, noop, () => {
+				storeSnapshotRef.current = { ...store };
+				if (effect?.dirty) effect.run();
+			});
+			activeEffect.value = effect;
+			effect.run();
+			effectMap.set(_id.current, effect);
+		}
+		return store;
+	}
+	useStore.$id = id;
+	return useStore;
+}
+
+//#endregion
+export { createPinia, defineStore, pinia, setActivePinia };

package/package.json

@@ -1,12 +1,75 @@
 {
   "name": "pinia-react",
-  "version": "1.0.0",
-  "main": "index.js",
+  "version": "1.1.1",
+  "type": "module",
+  "homepage": "https://github.com/savageKarl/pinia-react#readme",
+  "bugs": {
+    "url": "https://github.com/savageKarl/pinia-react/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/savageKarl/pinia-react.git"
+  },
+  "author": "savageKarl <shan.revolt@gmail.com>",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "prepare": "npx simple-git-hooks",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "playground": "vite --config playground/vite.config.ts",
+    "test": "vitest",
+    "semantic-release": "semantic-release"
+  },
+  "keywords": [
+    "pinia",
+    "react-pinia",
+    "react-store"
+  ],
+  "license": "MIT",
+  "description": "",
+  "simple-git-hooks": {
+    "commit-msg": "npx --no-install commitlint --edit \"$1\""
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.1.3",
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@testing-library/jest-dom": "^6.6.4",
+    "@testing-library/react": "^16.3.0",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/node": "^22.15.17",
+    "@types/react": "^19.1.3",
+    "@types/react-dom": "^19.1.4",
+    "@vitejs/plugin-react": "^5.0.0",
+    "jsdom": "^26.1.0",
+    "semantic-release": "^24.2.7",
+    "simple-git-hooks": "^2.13.1",
+    "tsdown": "^0.13.3",
+    "typescript": "^5.8.3",
+    "vite": "npm:rolldown-vite@latest",
+    "vitest": "^3.2.4"
   },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "description": ""
+  "dependencies": {
+    "@maoism/runtime-core": "^3.4.13",
+    "savage-types": "^1.0.20",
+    "savage-utils": "^1.0.65"
+  }
 }