@vef-framework/core 1.0.135 → 2.0.1

package/dist/cjs/store/unbound.cjs

@@ -0,0 +1,74 @@
+/*! @vef-framework/core v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:30.112Z */
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const jsxRuntime = require('@emotion/react/jsx-runtime');
+const shared = require('@vef-framework/shared');
+const react$1 = require('motion/react');
+const react = require('react');
+const zustand = require('zustand');
+const middleware = require('zustand/middleware');
+const immer = require('zustand/middleware/immer');
+
+const contextCache = /* @__PURE__ */ new Map();
+function createComponentStore(name, initializer) {
+  const contextKey = `${name}StoreContext`;
+  let Context = contextCache.get(contextKey);
+  if (!Context) {
+    Context = react.createContext(null);
+    Context.displayName = contextKey;
+    contextCache.set(contextKey, Context);
+  }
+  function StoreProvider(props) {
+    const { children } = props;
+    const storeRef = react.useRef(null);
+    const storeInitializedRef = react.useRef(false);
+    const latestInitialStateRef = react.useRef(void 0);
+    latestInitialStateRef.current = props.initialState;
+    if (!storeRef.current || !storeInitializedRef.current) {
+      storeRef.current = zustand.createStore()(
+        middleware.subscribeWithSelector(
+          immer.immer(initializer)
+        )
+      );
+      storeInitializedRef.current = true;
+    }
+    react$1.useIsomorphicLayoutEffect(() => {
+      if (!shared.isPlainObject(latestInitialStateRef.current)) {
+        return;
+      }
+      if (storeRef.current) {
+        storeRef.current.setState((state) => {
+          shared.mergeWith(
+            state,
+            latestInitialStateRef.current,
+            true
+          );
+        });
+      }
+    }, []);
+    return /* @__PURE__ */ jsxRuntime.jsx(Context, { value: storeRef.current, children });
+  }
+  function useStoreApi() {
+    const store = react.use(Context);
+    if (!store) {
+      const isDev = process.env.NODE_ENV === "development";
+      const errorMessage = `${name}Store is not found in the React context, please check if the store is wrapped in a ${name}StoreProvider`;
+      const devHint = isDev ? "\n\nDev hint: If you're seeing this error after hot reload, it might be a React Fast Refresh issue. Try refreshing the page." : "";
+      throw new Error(errorMessage + devHint);
+    }
+    return store;
+  }
+  function useStore(selector) {
+    const store = useStoreApi();
+    return zustand.useStore(store, selector);
+  }
+  return {
+    StoreProvider,
+    useStoreApi,
+    useStore
+  };
+}
+
+exports.createComponentStore = createComponentStore;

package/dist/cjs/store/use-deep.cjs

@@ -0,0 +1,17 @@
+/*! @vef-framework/core v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:30.112Z */
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const shared = require('@vef-framework/shared');
+const react = require('react');
+
+function useDeep(selector) {
+  const prevRef = react.useRef(null);
+  return (state) => {
+    const next = selector(state);
+    return shared.isDeepEqual(prevRef.current, next) ? prevRef.current : prevRef.current = next;
+  };
+}
+
+exports.useDeep = useDeep;

package/dist/es/api/client.js

@@ -0,0 +1,167 @@
+/*! @vef-framework/core v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:30.112Z */
+import { isFunction } from '@vef-framework/shared';
+import '../http/index.js';
+import '../query/index.js';
+import { QUERY_CLIENT, PROXIED_METHODS } from './constants.js';
+import { createHttpClient } from '../http/helpers.js';
+import { createQueryClient } from '../query/helpers.js';
+
+class ApiClient {
+  /**
+   * The HTTP client.
+   */
+  #httpClient;
+  /**
+   * The query client.
+   */
+  #queryClient;
+  /**
+   * The current signal.
+   */
+  #currentSignal;
+  /**
+   * The query client.
+   */
+  get [QUERY_CLIENT]() {
+    return this.#queryClient;
+  }
+  /**
+   * Creates a new API client.
+   *
+   * @param options - The options for the API client.
+   */
+  constructor(options) {
+    const {
+      http,
+      query
+    } = options;
+    this.#httpClient = createHttpClient(http);
+    this.#queryClient = createQueryClient(query);
+    const proxyCache = /* @__PURE__ */ new Map();
+    this.#httpClient = new Proxy(this.#httpClient, {
+      get: (target, prop, receiver) => {
+        const value = Reflect.get(target, prop, receiver);
+        if (!isFunction(value)) {
+          return value;
+        }
+        if (!proxyCache.has(prop)) {
+          if (PROXIED_METHODS.includes(prop)) {
+            proxyCache.set(prop, (url, options2) => value.apply(
+              target,
+              [
+                url,
+                {
+                  ...options2,
+                  signal: this.#currentSignal
+                }
+              ]
+            ));
+          } else {
+            proxyCache.set(prop, (...args) => value.apply(target, args));
+          }
+        }
+        return proxyCache.get(prop);
+      }
+    });
+  }
+  /**
+   * Creates a new query function.
+   *
+   * @param key - The key of the query function.
+   * @param factory - The factory function.
+   * @returns The query function.
+   */
+  createQueryFn(key, factory) {
+    const queryFn = factory(this.#httpClient);
+    const wrapperFn = (context) => {
+      const {
+        queryKey,
+        signal,
+        pageParam,
+        meta
+      } = context;
+      const [, params] = queryKey;
+      try {
+        this.#currentSignal = signal;
+        return queryFn(
+          params,
+          pageParam,
+          meta
+        );
+      } finally {
+        this.#currentSignal = void 0;
+      }
+    };
+    Object.defineProperty(wrapperFn, "key", {
+      value: key,
+      configurable: false,
+      writable: false,
+      enumerable: false
+    });
+    return wrapperFn;
+  }
+  /**
+   * Creates a new mutation function.
+   *
+   * @param key - The key of the mutation function.
+   * @param factory - The factory function.
+   * @returns The mutation function.
+   */
+  createMutationFn(key, factory) {
+    const mutationFn = factory(this.#httpClient);
+    const wrapperFn = (params) => mutationFn(params);
+    Object.defineProperty(wrapperFn, "key", {
+      value: key,
+      configurable: false,
+      writable: false,
+      enumerable: false
+    });
+    return wrapperFn;
+  }
+  /**
+   * Fetches a query.
+   *
+   * @param options - The options for the query.
+   * @returns The result of the query.
+   */
+  async fetchQuery(options) {
+    return await this.#queryClient.fetchQuery(options);
+  }
+  /**
+   * Prefetches a query and stores the result in cache.
+   *
+   * @param options - The options for the query.
+   * @returns A promise that resolves when the prefetch is complete.
+   */
+  async prefetchQuery(options) {
+    return await this.#queryClient.prefetchQuery(options);
+  }
+  /**
+   * Executes a mutation outside of React components.
+   *
+   * This method allows you to execute mutations imperatively without using the `useMutation` hook.
+   * Useful for scenarios like login flows, event handlers, or any code outside React components.
+   *
+   * @template TData - The type of data returned by the mutation
+   * @template TParams - The type of parameters passed to the mutation function
+   * @template TOnMutateResult - The type of result returned by onMutate callback
+   *
+   * @param options - The mutation options including mutationFn, onSuccess, onError, etc.
+   * @param variables - The variables to pass to the mutation function. Omit this argument when the mutation does not require parameters.
+   * @remarks This reuses TanStack Query's imperative mutation execution so lifecycle callbacks (onMutate, onSuccess, etc.) still fire.
+   * @returns A promise that resolves with the mutation result
+   */
+  async executeMutation({
+    mutationFn,
+    params,
+    ...options
+  }) {
+    return await this.#queryClient.getMutationCache().build(this.#queryClient, {
+      mutationKey: [mutationFn.key],
+      mutationFn,
+      ...options
+    }).execute(params);
+  }
+}
+
+export { ApiClient };

package/dist/es/api/constants.js

@@ -0,0 +1,8 @@
+/*! @vef-framework/core v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:30.112Z */
+import '../query/index.js';
+import { QUERY_CLIENT_KEY } from '../query/constants.js';
+
+const PROXIED_METHODS = ["get", "post", "put", "delete", "upload", "download"];
+const QUERY_CLIENT = Symbol.for(QUERY_CLIENT_KEY);
+
+export { PROXIED_METHODS, QUERY_CLIENT };

package/dist/es/api/helpers.js

@@ -0,0 +1,8 @@
+/*! @vef-framework/core v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:30.112Z */
+import { ApiClient } from './client.js';
+
+function createApiClient(options) {
+  return new ApiClient(options);
+}
+
+export { createApiClient };

package/dist/es/api/index.js

@@ -0,0 +1,4 @@
+/*! @vef-framework/core v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:30.112Z */
+export { ApiClient } from './client.js';
+export { QUERY_CLIENT } from './constants.js';
+export { createApiClient } from './helpers.js';

package/dist/es/auth/helpers.js

@@ -0,0 +1,15 @@
+/*! @vef-framework/core v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:30.112Z */
+import { isNullish, isString } from '@vef-framework/shared';
+
+function checkPermission(hasPermission, permTokens, checkMode = "any") {
+  if (isNullish(permTokens)) {
+    return true;
+  }
+  const normalizedPermTokens = isString(permTokens) ? [permTokens] : permTokens;
+  if (checkMode === "any") {
+    return normalizedPermTokens.some((token) => hasPermission(token));
+  }
+  return normalizedPermTokens.every((token) => hasPermission(token));
+}
+
+export { checkPermission };

package/dist/es/auth/index.js

@@ -0,0 +1,2 @@
+/*! @vef-framework/core v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:30.112Z */
+export { checkPermission } from './helpers.js';

package/dist/es/common/index.js

@@ -0,0 +1 @@
+/*! @vef-framework/core v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:30.112Z */

package/dist/es/context/api-client.js

@@ -0,0 +1,20 @@
+/*! @vef-framework/core v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:30.112Z */
+import { jsx } from '@emotion/react/jsx-runtime';
+import { QueryClientProvider } from '@tanstack/react-query';
+import { createContext, use } from 'react';
+import '../api/index.js';
+import { QUERY_CLIENT } from '../api/constants.js';
+
+const Context = createContext(null);
+function ApiClientProvider({ value, children }) {
+  return /* @__PURE__ */ jsx(Context, { value, children: /* @__PURE__ */ jsx(QueryClientProvider, { client: value[QUERY_CLIENT], children }) });
+}
+function useApiClient() {
+  const apiClient = use(Context);
+  if (!apiClient) {
+    throw new Error("No 'ApiClientContext' found in the React app, please use 'ApiClientProvider' to wrap your app.");
+  }
+  return apiClient;
+}
+
+export { ApiClientProvider, useApiClient };

package/dist/es/context/app.js

@@ -0,0 +1,10 @@
+/*! @vef-framework/core v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:30.112Z */
+import { createContext, use } from 'react';
+
+const Context = createContext({});
+const AppContextProvider = Context.Provider;
+function useAppContext() {
+  return use(Context);
+}
+
+export { AppContextProvider, useAppContext };

package/dist/es/context/context-selector.js

@@ -0,0 +1,61 @@
+/*! @vef-framework/core v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:30.112Z */
+import { jsx } from '@emotion/react/jsx-runtime';
+import { isFunction } from '@vef-framework/shared';
+import { createContext, useState, useEffect, use, useSyncExternalStore } from 'react';
+
+function createContextWithSelector(defaultValue) {
+  const Context = createContext(createStore(defaultValue));
+  function Provider({ value, children }) {
+    const [store] = useState(() => createStore(value));
+    useEffect(() => {
+      if (!Object.is(store.value, value)) {
+        store.value = value;
+        store.notify();
+      }
+    });
+    return /* @__PURE__ */ jsx(Context, { value: store, children });
+  }
+  Provider.displayName = "SelectorContextProvider";
+  function useContext(selector) {
+    const store = use(Context);
+    return useSyncExternalStore(
+      store.subscribe,
+      // Get current value, applying selector if provided
+      () => isFunction(selector) ? selector(store.value) : store.value,
+      // Server-side snapshot (same as client-side for consistency)
+      () => isFunction(selector) ? selector(store.value) : store.value
+    );
+  }
+  return {
+    Provider,
+    useContext
+  };
+}
+function createStore(value) {
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    value,
+    /**
+     * Subscribe to store changes
+     *
+     * @param listener - Function to call when store value changes
+     * @returns Unsubscribe function
+     */
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    /**
+     * Notify all subscribers that the value has changed
+     */
+    notify: () => {
+      for (const listener of listeners) {
+        listener();
+      }
+    }
+  };
+}
+
+export { createContextWithSelector };

package/dist/es/context/disabled.js

@@ -0,0 +1,10 @@
+/*! @vef-framework/core v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:30.112Z */
+import { createContext, use } from 'react';
+
+const DisabledContext = createContext(false);
+function useDisabled() {
+  return use(DisabledContext);
+}
+const DisabledProvider = DisabledContext.Provider;
+
+export { DisabledProvider, useDisabled };

package/dist/es/context/index.js

@@ -0,0 +1,5 @@
+/*! @vef-framework/core v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:30.112Z */
+export { ApiClientProvider, useApiClient } from './api-client.js';
+export { AppContextProvider, useAppContext } from './app.js';
+export { createContextWithSelector } from './context-selector.js';
+export { DisabledProvider, useDisabled } from './disabled.js';

package/dist/es/dnd/index.js

@@ -0,0 +1,7 @@
+/*! @vef-framework/core v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:30.112Z */
+export { AxisModifier, RestrictToHorizontalAxis, RestrictToVerticalAxis, SnapModifier, restrictShapeToBoundingRectangle } from '@dnd-kit/abstract/modifiers';
+export { RestrictToElement, RestrictToWindow } from '@dnd-kit/dom/modifiers';
+export { arrayMove as moveArrayItem, move as moveDragItem, arraySwap as swapArrayItem, swap as swapDragItem } from '@dnd-kit/helpers';
+export { DragDropProvider, DragOverlay, KeyboardSensor, PointerSensor, useDragDropMonitor, useDraggable, useDroppable } from '@dnd-kit/react';
+export { useSortable } from '@dnd-kit/react/sortable';
+export { DragDropContext, Draggable, Droppable } from '@hello-pangea/dnd';