@mic-rexjs/usecases-react 1.3.36 → 1.4.1

package/es/hooks/useUseCase/types.d.ts

@@ -1,25 +1,39 @@
+import { ContextualEntityReducers } from '../../configs/defaultUseCaseContext/types';
 import { EntityReducers, EntityUseCase, Reducers, UseCase } from '@mic-rexjs/usecases';
-import { UseCaseContext, UseCaseContextWithProvider } from '../../configs/usecaseContextMap/types';
+import { UseCaseProvider } from '../useProvider/types';
+export type CoreCollection<T, TEntityReducers extends EntityReducers<T>, TProvide extends UseCaseProvider | null = UseCaseProvider> = [entity: T, reducers: ContextualEntityReducers<T, TEntityReducers>, Provider: TProvide];
 export interface EntityGetter<T> {
     (): T;
 }
-export interface EntityWatcher<T> {
-    (newEntity: T, prevEntity: T): void;
+export interface EntityWatchEvent<T, TValue = unknown> {
+    fieldPaths: string[];
+    newEntity: T;
+    newValue: TValue;
+    oldEntity: T;
+    oldValue: TValue;
 }
-export type EntityWatchMap<T> = T extends unknown[] ? Record<number, EntityWatcher<T>> : T extends object ? {
-    [K in keyof T]?: EntityWatcher<T>;
-} : object;
+export interface EntityWatcher<T, TValue = unknown> {
+    (event: EntityWatchEvent<T, TValue>): void;
+}
+export type PropertyPath<T, K extends keyof T = keyof T & string> = K extends infer TKey ? `${TKey & (string | number)}${'' | DotAccessorFieldPath<T[TKey & keyof T]>}` : never;
+export type DotAccessorFieldPath<T> = T extends unknown[] ? '.length' | `${'' | `.${number}`}${DotAccessorFieldPath<T[number]>}` : T extends object ? `.${PropertyPath<T>}` : '';
+export type FieldPath<T> = T extends unknown[] ? FieldPath<T[number]> | 'length' : T extends object ? PropertyPath<T> : never;
+export type ExtractPropertyType<T, TPath> = TPath extends `${infer TKey}.${infer TSubPath}` ? T extends unknown[] ? ExtractPropertyType<T[number], TKey extends `${number}` ? TSubPath : TPath> : ExtractPropertyType<T[TKey & keyof T], TSubPath> : T extends unknown[] ? TPath extends 'length' ? T[TPath] : TPath extends `${number}` ? T[number] : ExtractPropertyType<T[number], TPath> : T[TPath & keyof T];
+export type ExtractFieldType<T, TPath> = TPath extends `${infer TKey}.${infer TSubProperty}` ? ExtractPropertyType<T[TKey & keyof T], TSubProperty> : T[TPath & keyof T];
+export type EntityWatchMap<T> = {
+    [K in FieldPath<T>]?: EntityWatcher<T, ExtractFieldType<T, K>>;
+};
 export interface UseCaseHookContextualOptions<T> {
     watch?: EntityWatchMap<T>;
-    onChange?(newEntity: T, prevEntity: T): void;
+    onChange?(newEntity: T, oldEntity: T): void;
 }
-export interface UseCaseHookOwnOptions<T, TOptions extends object> extends UseCaseHookContextualOptions<T> {
+export interface UseCaseHookOwnOptions<T, TUseCaseOptions extends object> extends UseCaseHookContextualOptions<T> {
     stateless?: boolean;
-    options?: TOptions;
+    options?: TUseCaseOptions;
 }
-export type UseCaseHookOptions<T, TOptions extends object> = TOptions & UseCaseHookOwnOptions<T, TOptions>;
+export type UseCaseHookOptions<T, TUseCaseOptions extends object = object> = TUseCaseOptions & UseCaseHookOwnOptions<T, TUseCaseOptions>;
 export interface UseCaseHook {
-    <T, TReducers extends EntityReducers<T>, TOptions extends UseCaseHookContextualOptions<T> = UseCaseHookContextualOptions<T>>(usecase: EntityUseCase<T, TReducers & EntityReducers<T>>, options?: TOptions): UseCaseContext<T, TReducers>;
-    <T, TReducers extends EntityReducers<T>, TUseCaseOptions extends object = object, TOptions extends UseCaseHookOptions<T, TUseCaseOptions> = UseCaseHookOptions<T, TUseCaseOptions>>(defaultEntity: T | EntityGetter<T>, usecase: EntityUseCase<T, TReducers, TUseCaseOptions> & UseCase<TReducers, TUseCaseOptions>, options?: TOptions, deps?: unknown[]): UseCaseContextWithProvider<T, TReducers>;
-    <T extends Reducers, TOptions extends object = object>(usecase: UseCase<T, TOptions>, options?: TOptions, deps?: unknown[]): T;
+    <T, TEntityReducers extends EntityReducers<T>>(usecase: EntityUseCase<T, TEntityReducers & EntityReducers<T>> & UseCase<TEntityReducers>, options?: UseCaseHookContextualOptions<T>): CoreCollection<T, TEntityReducers, null>;
+    <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object>(initailEntity: T | EntityGetter<T>, usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions> & UseCase<TEntityReducers, TUseCaseOptions>, options?: UseCaseHookOptions<T, TUseCaseOptions>, deps?: unknown[]): CoreCollection<T, TEntityReducers>;
+    <T extends Reducers, TUseCaseOptions extends object = object>(usecase: UseCase<T, TUseCaseOptions>, options?: TUseCaseOptions, deps?: unknown[]): T;
 }

package/es/hooks/useUseCaseContext/index.d.ts

@@ -0,0 +1,3 @@
+import { EntityReducers, EntityUseCase } from '@mic-rexjs/usecases';
+import { UseCaseMappingContext } from '../../configs/usecaseContextMap/types';
+export declare const useUseCaseContext: <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object, TContext extends UseCaseMappingContext<T, TEntityReducers, TUseCaseOptions> = UseCaseMappingContext<T, TEntityReducers, TUseCaseOptions>>(usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions>, defaultContext?: TContext | null | undefined) => TContext;

package/es/hooks/useUseCaseContext/index.js

@@ -0,0 +1,17 @@
+import { useConstant } from '../useConstant';
+import { usecaseContextMap } from '../../configs/usecaseContextMap';
+import { createContext } from 'react';
+export const useUseCaseContext = (usecase, defaultContext) => {
+    return useConstant(() => {
+        const map = usecaseContextMap;
+        if (map.has(usecase)) {
+            return map.get(usecase);
+        }
+        if (defaultContext) {
+            return defaultContext;
+        }
+        const ctx = createContext({});
+        map.set(usecase, ctx);
+        return ctx;
+    });
+};

package/es/index.d.ts

@@ -1,5 +1,6 @@
 export { UseCaseFragment } from './components/UseCaseFragment';
 export { useUseCase } from './hooks/useUseCase';
-export type { UseCaseFragmentProps } from './components/UseCaseFragment/types';
-export type { UseCaseContext, UseCaseContextWithProvider, UseCaseProvider } from './configs/usecaseContextMap/types';
+export type { CoreCollection } from './hooks/useUseCase/types';
 export type { UseCaseHookOptions } from './hooks/useUseCase/types';
+export type { UseCaseProvider } from './hooks/useProvider/types';
+export type { UseCaseFragmentProps } from './components/UseCaseFragment/types';

package/es/methods/compareProperty/index.d.ts

@@ -0,0 +1,2 @@
+import { ComparePropertyCallback } from './types';
+export declare const compareProperty: <T, S>(from: T, to: S, fieldPath: string, callback: ComparePropertyCallback, fieldPathStack?: string[]) => void;

package/es/methods/compareProperty/index.js

@@ -0,0 +1,34 @@
+import { hasField } from '../hasField';
+export const compareProperty = (from, to, fieldPath, callback, fieldPathStack = []) => {
+    const undef = void 0;
+    const [, key = fieldPath, subFieldPath = ''] = fieldPath.match(/^([^.]+)\.(.+)$/) || [];
+    const hasFromField = hasField(from, key);
+    const hasToField = hasField(to, key);
+    const currentFieldPathStack = [...fieldPathStack, key];
+    if (hasFromField || hasToField) {
+        const fromValue = hasFromField ? from[key] : undef;
+        const toValue = hasToField ? to[key] : undef;
+        if (subFieldPath) {
+            compareProperty(fromValue, toValue, subFieldPath, callback, currentFieldPathStack);
+            return;
+        }
+        if (fromValue === toValue) {
+            return;
+        }
+        callback(fromValue, toValue, currentFieldPathStack);
+        return;
+    }
+    if (/^\d+^/.test(key)) {
+        return;
+    }
+    const fromArray = Array.isArray(from) ? from : [];
+    const toArray = Array.isArray(to) ? to : [];
+    const { length: fromLength } = fromArray;
+    const { length: toLength } = toArray;
+    const length = Math.max(fromLength, toLength);
+    for (let i = 0; i < length; i++) {
+        const fromItem = fromArray[i];
+        const toItem = toArray[i];
+        compareProperty(fromItem, toItem, fieldPath, callback, [...fieldPathStack, `${i}`]);
+    }
+};

package/es/methods/compareProperty/types.d.ts

@@ -0,0 +1,3 @@
+export interface ComparePropertyCallback {
+    <T, S>(fromValue: T, toValue: S, fieldPaths: string[]): void;
+}

package/es/methods/compareProperty/types.js

@@ -0,0 +1 @@
+export {};

package/es/methods/getRootEntity/index.d.ts

@@ -0,0 +1,2 @@
+import { EntityGetter } from '../../hooks/useUseCase/types';
+export declare const getRootEntity: <T>(entityState: T, entityArg: T | EntityGetter<T>, stateless?: boolean) => T;

package/es/methods/getRootEntity/index.js

@@ -0,0 +1,9 @@
+export const getRootEntity = (entityState, entityArg, stateless) => {
+    if (!stateless) {
+        return entityState;
+    }
+    if (typeof entityArg === 'function') {
+        return entityArg();
+    }
+    return entityArg;
+};

package/es/methods/hasField/index.d.ts

@@ -0,0 +1 @@
+export declare const hasField: <T>(data: T, field: string) => boolean;

package/es/methods/hasField/index.js

@@ -0,0 +1,6 @@
+export const hasField = (data, field) => {
+    if (typeof data !== 'object' || data === null) {
+        return false;
+    }
+    return Object.hasOwn(data, field);
+};

package/es/methods/initEntityReducers/index.d.ts

@@ -0,0 +1,5 @@
+import { EntityReducers, EntityUseCase } from '@mic-rexjs/usecases';
+import { UseCaseHookOptions } from '../../hooks/useUseCase/types';
+import { ContextualEntityReducers } from '../../configs/defaultUseCaseContext/types';
+import { EntityChangeEventHandler } from './types';
+export declare const initEntityReducers: <T, TEntityReducers extends EntityReducers<T>, TUseCaseOptions extends object = object>(entity: T, usecase: EntityUseCase<T, TEntityReducers, TUseCaseOptions>, options: UseCaseHookOptions<T, TUseCaseOptions>, onEntityChange: EntityChangeEventHandler<T>) => ContextualEntityReducers<T, TEntityReducers>;

package/es/methods/initEntityReducers/index.js

@@ -0,0 +1,13 @@
+import { entityReducerUseCase } from '@mic-rexjs/usecases';
+export const initEntityReducers = (entity, usecase, options, onEntityChange) => {
+    const { createEntityReducers } = entityReducerUseCase();
+    const { stateless, watch, onChange, options: usecaseOptions, ...restUseCaseOptions } = options;
+    return createEntityReducers(entity, usecase, {
+        ...restUseCaseOptions,
+        ...usecaseOptions,
+        onChange: onEntityChange,
+        onGenerate(newEntity, result) {
+            return result;
+        },
+    });
+};

package/es/methods/initEntityReducers/types.d.ts

@@ -0,0 +1,3 @@
+export interface EntityChangeEventHandler<T> {
+    (newEntity: T, oldEntity: T): void;
+}

package/es/methods/initEntityReducers/types.js

@@ -0,0 +1 @@
+export {};

package/es/methods/removeItem/index.d.ts

@@ -0,0 +1 @@
+export declare const removeItem: <T>(list: T[], item: T) => void;

package/es/methods/removeItem/index.js

@@ -0,0 +1,7 @@
+export const removeItem = (list, item) => {
+    const index = list.indexOf(item);
+    if (index === -1) {
+        return;
+    }
+    list.splice(index, 1);
+};

package/es/methods/triggerCallbacks/index.d.ts

@@ -0,0 +1,3 @@
+import { OptionsRefCollection } from '../../hooks/useOptionsRefCollection/types';
+import { UseCaseHookOptions } from '../../hooks/useUseCase/types';
+export declare const triggerCallbacks: <T, TUseCaseOptions extends object, TOptions extends UseCaseHookOptions<T, TUseCaseOptions> = UseCaseHookOptions<T, TUseCaseOptions>>(optionsRefCollection: OptionsRefCollection<TOptions>, newEntity: T, oldEntity: T) => void;

package/es/methods/triggerCallbacks/index.js

@@ -0,0 +1,14 @@
+import { triggerWatchers } from '../triggerWatchers';
+export const triggerCallbacks = (optionsRefCollection, newEntity, oldEntity) => {
+    for (let { length: i } = optionsRefCollection; i > 0; i--) {
+        const { current: options } = optionsRefCollection[i - 1];
+        if (!options) {
+            continue;
+        }
+        const { onChange, watch } = options;
+        if (watch) {
+            triggerWatchers(watch, newEntity, oldEntity);
+        }
+        onChange?.(newEntity, oldEntity);
+    }
+};

package/es/methods/triggerWatchers/index.d.ts

@@ -0,0 +1,2 @@
+import { EntityWatchMap } from '../../hooks/useUseCase/types';
+export declare const triggerWatchers: <T>(watch: EntityWatchMap<T>, newEntity: T, oldEntity: T) => void;

package/es/methods/triggerWatchers/index.js

@@ -0,0 +1,14 @@
+import { compareProperty } from '../compareProperty';
+export const triggerWatchers = (watch, newEntity, oldEntity) => {
+    for (const [fieldPath, watcher] of Object.entries(watch)) {
+        compareProperty(oldEntity, newEntity, fieldPath, (oldValue, newValue, fieldPaths) => {
+            watcher({
+                fieldPaths,
+                newEntity,
+                oldEntity,
+                newValue,
+                oldValue,
+            });
+        });
+    }
+};

package/lib/components/UpdateFragment/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UpdateFragment = void 0;
+var _jsxRuntime = require("react/jsx-runtime");
+var _react = require("react");
+var UpdateFragment = function UpdateFragment(_ref) {
+  var onUpdate = _ref.onUpdate;
+  (0, _react.useEffect)(function () {
+    onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate();
+  });
+  return (0, _jsxRuntime.jsx)(_react.Fragment, {});
+};
+exports.UpdateFragment = UpdateFragment;

package/lib/configs/defaultUseCaseContext/index.js

@@ -5,5 +5,5 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.defaultUseCaseContext = void 0;
 var _react = require("react");
-var defaultUseCaseContext = (0, _react.createContext)(null);
+var defaultUseCaseContext = (0, _react.createContext)({});
 exports.defaultUseCaseContext = defaultUseCaseContext;

package/lib/configs/defaultUseCaseContext/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/hooks/useCompareDeps/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCompareDeps = void 0;
+var _react = require("react");
+var _useScope = require("../useScope");
+var useCompareDeps = function useCompareDeps(deps) {
+  var updateTimesRef = (0, _react.useRef)(0);
+  var prevDepsRef = (0, _react.useRef)([]);
+  var prevDeps = prevDepsRef.current;
+  var prevLength = prevDeps.length;
+  var length = deps.length;
+  var updated = (0, _useScope.useScope)(function () {
+    if (length !== prevLength) {
+      return true;
+    }
+    for (var i = 0; i < length; i++) {
+      if (deps[i] === prevDeps[i]) {
+        continue;
+      }
+      return true;
+    }
+    return false;
+  });
+  prevDepsRef.current = deps;
+  updateTimesRef.current += updated ? 1 : 0;
+  return updateTimesRef.current;
+};
+exports.useCompareDeps = useCompareDeps;

package/lib/hooks/useConstant/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useConstant = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var useConstant = function useConstant(initialValue) {
+  var _useState = (0, _react.useState)(initialValue),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 1),
+    value = _useState2[0];
+  return value;
+};
+exports.useConstant = useConstant;

package/lib/hooks/useConstant/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/hooks/useConstantFn/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useConstantFn = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var useConstantFn = function useConstantFn(initialValue) {
+  var _useState = (0, _react.useState)(function () {
+      return initialValue;
+    }),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 1),
+    value = _useState2[0];
+  return value;
+};
+exports.useConstantFn = useConstantFn;

package/lib/hooks/useOptionsRefCollection/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useOptionsRefCollection = void 0;
+var _ahooks = require("ahooks");
+var _removeItem = require("../../methods/removeItem");
+var useOptionsRefCollection = function useOptionsRefCollection(isRoot, contextOptionsRefCollection, options) {
+  var optionsRef = (0, _ahooks.useLatest)(options);
+  var optionsRefCollection = (0, _ahooks.useCreation)(function () {
+    if (isRoot) {
+      return [];
+    }
+    return contextOptionsRefCollection;
+  }, [contextOptionsRefCollection, isRoot]);
+  var prevOptionsRefCollection = (0, _ahooks.usePrevious)(optionsRefCollection);
+  (0, _ahooks.useCreation)(function () {
+    if (prevOptionsRefCollection) {
+      (0, _removeItem.removeItem)(prevOptionsRefCollection, optionsRef);
+    }
+    optionsRefCollection.push(optionsRef);
+  }, [optionsRef, optionsRefCollection, prevOptionsRefCollection]);
+  (0, _ahooks.useUnmount)(function () {
+    (0, _removeItem.removeItem)(optionsRefCollection, optionsRef);
+  });
+  return optionsRefCollection;
+};
+exports.useOptionsRefCollection = useOptionsRefCollection;

package/lib/hooks/useOptionsRefCollection/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/hooks/useProvider/index.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useProvider = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _useConstant = require("../useConstant");
+var _ahooks = require("ahooks");
+var useProvider = function useProvider(context, entity, reducers, optionsRefCollection) {
+  var contextValue = (0, _ahooks.useCreation)(function () {
+    return {
+      entity: entity,
+      reducers: reducers,
+      optionsRefCollection: optionsRefCollection
+    };
+  }, [entity, reducers, optionsRefCollection]);
+  var contextValueRef = (0, _ahooks.useLatest)(contextValue);
+  return (0, _useConstant.useConstant)(function () {
+    return function (_ref) {
+      var children = _ref.children;
+      var ContextProvider = context.Provider;
+      return _react["default"].createElement(ContextProvider, {
+        value: contextValueRef.current
+      }, children);
+    };
+  });
+};
+exports.useProvider = useProvider;

package/lib/hooks/useProvider/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/hooks/useScope/index.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useScope = void 0;
+var useScope = function useScope(scope) {
+  return scope();
+};
+exports.useScope = useScope;

package/lib/hooks/useScope/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});