floppy-disk 2.16.0 → 3.0.0-alpha.2

package/esm/vanilla.mjs

@@ -0,0 +1,109 @@
+const isClient = typeof window !== "undefined" && !("Deno" in window);
+const noop = () => {
+};
+const identity = (value) => value;
+const getValue = (valueOrComputeValueFn, ...params) => {
+  if (typeof valueOrComputeValueFn === "function") {
+    return valueOrComputeValueFn(...params);
+  }
+  return valueOrComputeValueFn;
+};
+
+const shallow = (a, b) => {
+  if (Object.is(a, b)) {
+    return true;
+  }
+  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+    return false;
+  }
+  if (a instanceof Map && b instanceof Map) {
+    if (a.size !== b.size) return false;
+    for (const [key, value] of a) {
+      if (!Object.is(value, b.get(key))) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (a instanceof Set && b instanceof Set) {
+    if (a.size !== b.size) return false;
+    for (const value of a) {
+      if (!b.has(value)) return false;
+    }
+    return true;
+  }
+  const keysA = Object.keys(a);
+  if (keysA.length !== Object.keys(b).length) {
+    return false;
+  }
+  for (let i = 0; i < keysA.length; i++) {
+    if (!Object.prototype.hasOwnProperty.call(b, keysA[i]) || !Object.is(a[keysA[i]], b[keysA[i]])) {
+      return false;
+    }
+  }
+  return true;
+};
+
+const hasObjectPrototype = (value) => {
+  return Object.prototype.toString.call(value) === "[object Object]";
+};
+const isPlainObject = (value) => {
+  if (!hasObjectPrototype(value)) return false;
+  const ctor = value.constructor;
+  if (typeof ctor === "undefined") return true;
+  const prot = ctor.prototype;
+  if (!hasObjectPrototype(prot)) return false;
+  if (!prot.hasOwnProperty("isPrototypeOf")) return false;
+  if (Object.getPrototypeOf(value) !== Object.prototype) return false;
+  return true;
+};
+const getHash = (value) => JSON.stringify(
+  value,
+  (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
+    result[key] = val[key];
+    return result;
+  }, {}) : val
+);
+
+const initStore = (initialState, options = {}) => {
+  const {
+    onFirstSubscribe = noop,
+    onSubscribe = noop,
+    onUnsubscribe = noop,
+    onLastUnsubscribe = noop
+  } = options;
+  const subscribers = /* @__PURE__ */ new Set();
+  const getSubscribers = () => subscribers;
+  const subscribe = (subscriber) => {
+    subscribers.add(subscriber);
+    if (subscribers.size === 1) onFirstSubscribe(state, storeApi);
+    onSubscribe(state, storeApi);
+    return () => {
+      subscribers.delete(subscriber);
+      onUnsubscribe(state, storeApi);
+      if (subscribers.size === 0) onLastUnsubscribe(state, storeApi);
+    };
+  };
+  let state = initialState;
+  const getState = () => state;
+  const setState = (value) => {
+    const prevState = state;
+    const newValue = getValue(value, state);
+    for (const key in newValue) {
+      if (!Object.is(prevState[key], newValue[key])) {
+        state = { ...prevState, ...newValue };
+        [...subscribers].forEach((subscriber) => subscriber(state, prevState));
+        return;
+      }
+    }
+  };
+  const storeApi = {
+    getState,
+    setState,
+    subscribe,
+    getSubscribers
+  };
+  return storeApi;
+};
+
+export { getHash, getValue, identity, initStore, isClient, isPlainObject, noop, shallow };

package/index.d.ts

@@ -0,0 +1 @@
+export * from 'floppy-disk/vanilla';

package/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var vanilla = require('floppy-disk/vanilla');
+
+
+
+Object.keys(vanilla).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return vanilla[k]; }
+	});
+});

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "floppy-disk",
-  "version": "2.16.0",
-  "description": "FloppyDisk - lightweight, simple, and powerful state management library",
+  "description": "Lightweight, simple, and powerful state management library",
+  "private": false,
+  "version": "3.0.0-alpha.2",
+  "publishConfig": {
+    "tag": "alpha"
+  },
   "keywords": [
+    "utilities",
+    "store",
     "state",
-    "manager",
-    "management",
     "react",
     "hooks",
-    "store",
-    "utilities",
     "query"
   ],
   "author": "Muhammad Afifudin",
@@ -24,59 +26,62 @@
   "homepage": "https://github.com/afiiif/floppy-disk#readme",
   "sideEffects": false,
   "files": [
-    "lib/",
-    "esm/",
-    "utils/"
+    "**"
   ],
-  "main": "./lib/index.js",
-  "module": "./esm/index.js",
-  "types": "./lib/index.d.ts",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "typesVersions": {
+    ">=4.5": {
+      "esm/*": [
+        "esm/*"
+      ],
+      "*": [
+        "*"
+      ]
+    },
+    "*": {
+      "esm/*": [
+        "ts_version_4.5_and_above_is_required.d.ts"
+      ],
+      "*": [
+        "ts_version_4.5_and_above_is_required.d.ts"
+      ]
+    }
+  },
   "exports": {
     "./package.json": "./package.json",
     ".": {
       "import": {
-        "types": "./esm/index.d.ts",
-        "default": "./esm/index.js"
-      },
-      "module": {
-        "types": "./esm/index.d.ts",
-        "default": "./esm/index.js"
+        "types": "./esm/index.d.mts",
+        "default": "./esm/index.mjs"
       },
       "default": {
-        "types": "./lib/index.d.ts",
-        "default": "./lib/index.js"
+        "types": "./index.d.ts",
+        "default": "./index.js"
       }
     },
-    "./utils": {
+    "./*": {
       "import": {
-        "types": "./esm/utils.d.ts",
-        "default": "./esm/utils.js"
-      },
-      "module": {
-        "types": "./esm/utils.d.ts",
-        "default": "./esm/utils.js"
+        "types": "./esm/*.d.mts",
+        "default": "./esm/*.mjs"
       },
       "default": {
-        "types": "./lib/utils.d.ts",
-        "default": "./lib/utils.js"
+        "types": "./*.d.ts",
+        "default": "./*.js"
       }
     }
   },
-  "release": {
-    "branches": [
-      "main",
-      {
-        "name": "beta",
-        "prerelease": true
-      },
-      {
-        "name": "alpha",
-        "prerelease": true
-      },
-      {
-        "name": "experimental",
-        "prerelease": true
-      }
-    ]
+  "packageManager": "pnpm@10.32.1",
+  "peerDependencies": {
+    "@types/react": ">=17.0",
+    "react": ">=17.0"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
   }
 }

package/react/create-mutation.d.ts

@@ -0,0 +1,135 @@
+import { type InitStoreOptions, type SetState } from 'floppy-disk/vanilla';
+/**
+ * Represents the state of a mutation.
+ *
+ * @remarks
+ * A mutation does not cache results and only tracks the latest execution.
+ *
+ * The state transitions are:
+ * - `INITIAL` → before any execution
+ * - `SUCCESS` → when mutation resolves successfully
+ * - `ERROR` → when mutation fails
+ *
+ * Unlike queries:
+ * - No retry mechanism
+ * - No caching across executions
+ */
+export type MutationState<TData, TVariable> = {
+    isPending: boolean;
+} & ({
+    state: 'INITIAL';
+    isSuccess: false;
+    isError: false;
+    variable: undefined;
+    data: undefined;
+    dataUpdatedAt: undefined;
+    error: undefined;
+    errorUpdatedAt: undefined;
+} | {
+    state: 'SUCCESS';
+    isSuccess: true;
+    isError: false;
+    variable: TVariable;
+    data: TData;
+    dataUpdatedAt: number;
+    error: undefined;
+    errorUpdatedAt: undefined;
+} | {
+    state: 'ERROR';
+    isSuccess: false;
+    isError: true;
+    variable: TVariable;
+    data: undefined;
+    dataUpdatedAt: undefined;
+    error: any;
+    errorUpdatedAt: number;
+});
+/**
+ * Configuration options for a mutation.
+ *
+ * @remarks
+ * Lifecycle callbacks are triggered for each execution.
+ */
+export type MutationOptions<TData, TVariable> = InitStoreOptions<MutationState<TData, TVariable>> & {
+    /**
+     * Called when the mutation succeeds.
+     */
+    onSuccess?: (data: TData, variable: TVariable, stateBeforeExecute: MutationState<TData, TVariable>) => void;
+    /**
+     * Called when the mutation fails.
+     */
+    onError?: (error: any, variable: TVariable, stateBeforeExecute: MutationState<TData, TVariable>) => void;
+    /**
+     * Called after the mutation settles (either success or error).
+     */
+    onSettled?: (variable: TVariable, stateBeforeExecute: MutationState<TData, TVariable>) => void;
+};
+/**
+ * Creates a mutation store for handling async operations that modify data.
+ *
+ * @param mutationFn - Async function that performs the mutation
+ * @param options - Optional configuration and lifecycle callbacks
+ *
+ * @returns A function that acts as both:
+ * - A React hook for subscribing to mutation state
+ * - A mutation controller (execute, reset, etc.)
+ *
+ * @remarks
+ * - Mutations are **not cached** and only track the latest execution.
+ * - Designed for operations that change data (e.g. create, update, delete).
+ * - No retry mechanism is provided by default.
+ * - Each execution overwrites the previous state.
+ * - The mutation always resolves (never throws): the result contains either `data` or `error`.
+ *
+ * @example
+ * const useCreateUser = createMutation(async (input) => {
+ *   return api.createUser(input);
+ * });
+ *
+ * const { isPending } = useCreateUser();
+ * const result = await useCreateUser.execute({ name: 'John' });
+ */
+export declare const createMutation: <TData, TVariable = undefined>(mutationFn: (variable: TVariable, stateBeforeExecute: MutationState<TData, TVariable>) => Promise<TData>, options?: MutationOptions<TData, TVariable>) => (<TStateSlice = MutationState<TData, TVariable>>(selector?: (state: MutationState<TData, TVariable>) => TStateSlice) => TStateSlice) & {
+    subscribe: (subscriber: import("../vanilla.ts").Subscriber<MutationState<TData, TVariable>>) => () => void;
+    getSubscribers: () => Set<import("../vanilla.ts").Subscriber<MutationState<TData, TVariable>>>;
+    getState: () => MutationState<TData, TVariable>;
+    /**
+     * Manually updates the mutation state.
+     *
+     * @remarks
+     * - Intended for advanced use cases.
+     * - Prefer using provided mutation actions (`execute`, `reset`) instead.
+     */
+    setState: (value: SetState<MutationState<TData, TVariable>>) => void;
+    /**
+     * Executes the mutation.
+     *
+     * @param variable - Input passed to the mutation function
+     *
+     * @returns A promise that always resolves with:
+     * - `{ data, variable }` on success
+     * - `{ error, variable }` on failure
+     *
+     * @remarks
+     * - If a mutation is already in progress, a warning is logged.
+     * - Concurrent executions are allowed but may lead to race conditions.
+     * - The promise never rejects to simplify async handling.
+     */
+    execute: TVariable extends undefined ? () => Promise<{
+        variable: undefined;
+        data?: TData;
+        error?: any;
+    }> : (variable: TVariable) => Promise<{
+        variable: TVariable;
+        data?: TData;
+        error?: any;
+    }>;
+    /**
+     * Resets the mutation state back to its initial state.
+     *
+     * @remarks
+     * - Does not cancel any ongoing request.
+     * - If a request is still pending, its result may override the reset state.
+     */
+    reset: () => void;
+};