synapse-storage 3.0.3 → 3.0.5

package/dist/reactive.js

@@ -1,604 +1 @@
-// src/reactive/dispatcher/dispatcher.module.ts
-import { Subject } from "rxjs";
-var Dispatcher = class {
-  /**
-   * Создает новый экземпляр Dispatcher
-   */
-  constructor(options) {
-    this.options = options;
-    this.storage = options.storage;
-    this.middlewareAPI = {
-      getState: () => this.storage.getState(),
-      dispatch: async (action) => {
-        this.actions$.next(action);
-        return action.payload;
-      },
-      storage: this.storage,
-      actions$: this.actions,
-      actions: this.dispatch,
-      watchers: this.watchers,
-      findActionByType: (type) => this.findActionByType(type),
-      findWatcherByType: (type) => this.findWatcherByType(type)
-    };
-    if (options.middlewares && options.middlewares.length > 0) {
-      this.use(...options.middlewares);
-    }
-  }
-  // Поток действий
-  actions$ = new Subject();
-  // Публичный Observable для действий
-  actions = this.actions$.asObservable();
-  // Методы диспетчеризации действий с типизацией
-  dispatch = {};
-  // Watcher'ы для реактивной подписки на изменения
-  watchers = {};
-  // Ссылка на хранилище
-  storage;
-  // Только один массив для хранения инициализированных middleware
-  middlewareFunctions = [];
-  // API для инициализации middleware
-  middlewareAPI;
-  /**
-   * Добавляет middleware в цепочку обработки
-   */
-  use(...middlewares) {
-    for (let i = 0; i < middlewares.length; i++) {
-      try {
-        const initializedMiddleware = middlewares[i](this.middlewareAPI);
-        this.middlewareFunctions.push(initializedMiddleware);
-      } catch (error) {
-        console.error(`Error initializing middleware [${i}]:`, error);
-      }
-    }
-    return this;
-  }
-  /**
-   * Получает все действия с улучшенной типизацией
-   */
-  getActions() {
-    return this.dispatch;
-  }
-  /**
-   * Получает типизированные действия диспетчера
-   */
-  getTypedDispatch() {
-    return this.dispatch;
-  }
-  /**
-   * Получает типизированные watcher'ы
-   */
-  getTypedWatchers() {
-    return this.watchers;
-  }
-  /**
-   * Находит действие по типу
-   */
-  findActionByType(actionType) {
-    return Object.values(this.dispatch).find((action) => {
-      return action.actionType.split(`[${this.storage.name}]`)[1] === actionType;
-    });
-  }
-  /**
-   * Находит наблюдатель по типу
-   */
-  findWatcherByType(actionType) {
-    return Object.values(this.watchers).find((watcher) => watcher.actionType === actionType);
-  }
-  /**
-   * Создает действие
-   */
-  createAction(actionConfig, executionOptions) {
-    const actionType = `[${this.storage.name}]${actionConfig.type}`;
-    let lastArgs = null;
-    let lastResult = null;
-    const dispatchFn = async (params) => {
-      const args = [params];
-      if (executionOptions?.memoize && lastArgs && lastResult) {
-        if (executionOptions.memoize(args, lastArgs, lastResult)) {
-          return lastResult;
-        }
-      }
-      const actionObject = {
-        type: actionType,
-        meta: actionConfig.meta
-      };
-      let result;
-      if (this.middlewareFunctions.length > 0) {
-        let chain = async (action) => {
-          if (executionOptions?.worker) {
-            return this.executeInWorker(executionOptions.worker, actionType, args, actionConfig.action);
-          } else {
-            return Promise.resolve(actionConfig.action(params));
-          }
-        };
-        for (let i = this.middlewareFunctions.length - 1; i >= 0; i--) {
-          const currentMiddleware = this.middlewareFunctions[i];
-          const nextChain = chain;
-          chain = async (action) => {
-            const next = async (nextAction) => nextChain(nextAction);
-            return currentMiddleware(next)(action);
-          };
-        }
-        result = await chain(actionObject);
-      } else {
-        if (executionOptions?.worker) {
-          result = await this.executeInWorker(executionOptions.worker, actionType, args, actionConfig.action);
-        } else {
-          result = await actionConfig.action(params);
-        }
-      }
-      actionObject.payload = result;
-      lastArgs = [...args];
-      lastResult = result;
-      this.actions$.next(actionObject);
-      return result;
-    };
-    dispatchFn._type = "dispatch";
-    Object.defineProperty(dispatchFn, "actionType", {
-      value: actionType,
-      writable: false,
-      enumerable: true
-    });
-    if (actionConfig.meta) {
-      Object.defineProperty(dispatchFn, "meta", {
-        value: actionConfig.meta,
-        writable: false,
-        enumerable: true
-      });
-    }
-    return dispatchFn;
-  }
-  /**
-   * Создает watcher для отслеживания изменений в хранилище
-   */
-  createWatcher(config) {
-    const actionType = `[${this.storage.name}]${config.type}`;
-    const subject = new Subject();
-    let prevValue;
-    const unsubscribe = this.storage.subscribe(config.selector, (value) => {
-      if (!config.shouldTrigger || config.shouldTrigger(prevValue, value)) {
-        const action = {
-          type: actionType,
-          payload: value,
-          meta: config.meta
-        };
-        this.actions$.next(action);
-        subject.next(action);
-        prevValue = value;
-      }
-    });
-    const watcherFn = () => subject.asObservable();
-    watcherFn._type = "watchers";
-    Object.defineProperty(watcherFn, "actionType", {
-      value: actionType,
-      writable: false,
-      enumerable: true
-    });
-    if (config.meta) {
-      Object.defineProperty(watcherFn, "meta", {
-        value: config.meta,
-        writable: false,
-        enumerable: true
-      });
-    }
-    Object.defineProperty(watcherFn, "unsubscribe", {
-      value: unsubscribe,
-      writable: false,
-      enumerable: true
-    });
-    return watcherFn;
-  }
-  /**
-   * Выполняет действие в worker
-   */
-  async executeInWorker(worker, actionType, args, fallbackAction) {
-    return new Promise((resolve, reject) => {
-      const requestId = `${actionType}_${Date.now()}_${Math.random()}`;
-      const handleMessage = (event) => {
-        if (event.data.requestId === requestId) {
-          worker.removeEventListener("message", handleMessage);
-          if (event.data.error) {
-            reject(new Error(event.data.error));
-          } else {
-            resolve(event.data.result);
-          }
-        }
-      };
-      worker.addEventListener("message", handleMessage);
-      worker.postMessage({
-        type: actionType,
-        args,
-        requestId
-      });
-      setTimeout(() => {
-        worker.removeEventListener("message", handleMessage);
-        reject(new Error(`Worker execution timeout for action: ${actionType}`));
-      }, 3e4);
-    });
-  }
-};
-function createDispatcher(options, actionsSetup) {
-  const dispatcher = new Dispatcher(options);
-  const actions = actionsSetup(options.storage, {
-    createAction: (actionConfig, executionOptions) => dispatcher.createAction(actionConfig, executionOptions),
-    createWatcher: (config) => dispatcher.createWatcher(config)
-  });
-  for (const [key, fn] of Object.entries(actions)) {
-    if (typeof fn === "function") {
-      const type = fn._type;
-      dispatcher[type][key] = fn;
-    }
-  }
-  return dispatcher;
-}
-
-// src/reactive/dispatcher/middlewares/logger.middleware.ts
-function getStateDiff(prevState, nextState) {
-  const diff = {};
-  const allKeys = [.../* @__PURE__ */ new Set([...Object.keys(prevState), ...Object.keys(nextState)])];
-  allKeys.forEach((key) => {
-    if (key in prevState && key in nextState) {
-      if (typeof prevState[key] === "object" && prevState[key] !== null && typeof nextState[key] === "object" && nextState[key] !== null && !Array.isArray(prevState[key]) && !Array.isArray(nextState[key])) {
-        const nestedDiff = getStateDiff(prevState[key], nextState[key]);
-        if (Object.keys(nestedDiff).length > 0) {
-          diff[key] = nestedDiff;
-        }
-      } else if (JSON.stringify(prevState[key]) !== JSON.stringify(nextState[key])) {
-        diff[key] = { PREV: prevState[key], NEXT: nextState[key] };
-      }
-    } else if (key in prevState) {
-      diff[key] = { PREV: prevState[key], NEXT: void 0 };
-    } else {
-      diff[key] = { PREV: void 0, NEXT: nextState[key] };
-    }
-  });
-  return diff;
-}
-var loggerDispatcherMiddleware = (options = {}) => {
-  const defaultTranslations = {
-    action: "\u0414\u0435\u0439\u0441\u0442\u0432\u0438\u0435",
-    prevState: "\u041F\u0440\u0435\u0434\u044B\u0434\u0443\u0449\u0435\u0435 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435",
-    nextState: "\u0421\u043B\u0435\u0434\u0443\u044E\u0449\u0435\u0435 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435",
-    duration: "\u0414\u043B\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u044C",
-    error: "\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u0434\u0435\u0439\u0441\u0442\u0432\u0438\u0438",
-    diff: "\u0418\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u044F",
-    changesCount: "\u041A\u043E\u043B\u0438\u0447\u0435\u0441\u0442\u0432\u043E \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439",
-    showFullState: "\u041F\u043E\u043B\u043D\u043E\u0435 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435"
-  };
-  const defaultOptions = {
-    collapsed: false,
-    duration: true,
-    diff: false,
-    showFullState: true,
-    // Показывать полное состояние по умолчанию
-    translations: defaultTranslations,
-    colors: {
-      title: "#3498db",
-      prevState: "#9E9E9E",
-      fullState: "#008a15",
-      action: "#03A9F4",
-      nextState: "#4CAF50",
-      error: "#F20404",
-      diff: "#9C27B0"
-    }
-  };
-  const mergedOptions = {
-    ...defaultOptions,
-    ...options,
-    // Объединяем переводы отдельно, чтобы позволить частичное переопределение
-    translations: {
-      ...defaultTranslations,
-      ...options.translations || {}
-    },
-    // Объединяем цвета отдельно, чтобы позволить частичное переопределение
-    colors: {
-      ...defaultOptions.colors,
-      ...options.colors || {}
-    }
-  };
-  const { collapsed, duration, colors, translations } = mergedOptions;
-  return (api) => (next) => async (action) => {
-    const started = Date.now();
-    const prevState = await api.getState();
-    try {
-      const result = await next(action);
-      const nextState = await api.getState();
-      const ended = Date.now();
-      const time = ended - started;
-      const title = `${action.type}`;
-      const groupMethod = collapsed ? console.groupCollapsed : console.group;
-      groupMethod(`%c ${title}`, `color: ${colors.title}; font-weight: bold`);
-      console.log(`%c ${translations.action}:`, `color: ${colors.action}; font-weight: bold`, action);
-      if (mergedOptions.diff) {
-        const stateDiff = getStateDiff(prevState, nextState);
-        const changesCount = Object.keys(stateDiff).length;
-        console.log(`%c ${translations.diff} (${translations.changesCount}: ${changesCount}):`, `color: ${colors.diff}; font-weight: bold`, stateDiff);
-      }
-      if (mergedOptions.showFullState) {
-        console.groupCollapsed(`%c ${translations.showFullState}`, `color: ${colors.fullState}; font-weight: bold`);
-        console.log(`%c ${translations.prevState}:`, `color: ${colors.prevState}; font-weight: bold`, prevState);
-        console.log(`%c ${translations.nextState}:`, `color: ${colors.nextState}; font-weight: bold`, nextState);
-        console.groupEnd();
-      }
-      if (duration) {
-        console.log(`%c ${translations.duration}: %c ${time}ms`, "font-weight: bold", "color: #4CAF50");
-      }
-      console.groupEnd();
-      return result;
-    } catch (error) {
-      console.error(`%c ${translations.error}:`, `color: ${colors.error}; font-weight: bold`, action.type, error);
-      throw error;
-    }
-  };
-};
-
-// src/reactive/effects/effects.module.ts
-import { combineLatest, merge, Observable as Observable4, of as of2, pipe, Subject as Subject2 } from "rxjs";
-import { catchError, filter, map, share, switchMap, take } from "rxjs/operators";
-
-// src/reactive/effects/utils/chunkRequestConsistent.ts
-import { of } from "rxjs";
-import { concatAll, delay, mergeMap, toArray } from "rxjs/operators";
-
-// src/_utils/chunk.util.ts
-function chunk(array, size = 1) {
-  if (size <= 0) throw new Error("Size must be greater than 0");
-  if (!array || !array.length) return [];
-  const result = [];
-  const length = array.length;
-  let index = 0;
-  while (index < length) {
-    result.push(array.slice(index, index + size));
-    index += size;
-  }
-  return result;
-}
-
-// src/reactive/effects/utils/chunkRequestConsistent.ts
-var chunkRequestConsistent = (fn, arr, size, delayMs = 0) => {
-  const chunks = chunk(arr, size).map((chunkItem) => of(chunkItem).pipe(delay(delayMs), mergeMap(fn)));
-  return of(...chunks).pipe(concatAll(), toArray());
-};
-
-// src/reactive/effects/utils/chunkRequestParallel.ts
-import { forkJoin, timer } from "rxjs";
-import { mergeMap as mergeMap2 } from "rxjs/operators";
-var chunkRequestParallel = (fn, arr, size, delayMs = 0) => forkJoin(chunk(arr, size).map((chunkItem, index) => timer(index * delayMs).pipe(mergeMap2(() => fn(chunkItem)))));
-
-// src/reactive/effects/effects.module.ts
-function ofType(actionFn) {
-  const { actionType } = actionFn;
-  if (!actionType) {
-    console.warn("ofType: Action function does not have actionType property", actionFn);
-    return filter(() => false);
-  }
-  return (source$) => {
-    return source$.pipe(filter((action) => action !== void 0 && action.type === actionType));
-  };
-}
-function ofTypes(actionFns) {
-  const actionTypes = actionFns.map((fn) => fn.actionType).filter(Boolean);
-  if (actionTypes.length === 0) {
-    console.warn("ofTypes: No valid action types found in array", actionFns);
-    return filter(() => false);
-  }
-  return (source$) => {
-    return source$.pipe(filter((action) => action !== void 0 && actionTypes.includes(action.type)));
-  };
-}
-function ofTypesWaitAll(actionFns) {
-  return (source$) => {
-    const actionTypes = actionFns.map((fn) => fn.actionType).filter(Boolean);
-    if (actionTypes.length === 0) {
-      console.warn("ofTypesWaitAll: No valid action types found in array", actionFns);
-      return of2([]);
-    }
-    const actionStreams = actionTypes.map(
-      (type, index) => source$.pipe(
-        filter((action) => action.type === type),
-        take(1),
-        map(
-          (action) => (
-            // Сохраняем ассоциацию с индексом, чтобы соответствовать
-            // порядку в исходном массиве actionFns
-            { index, action }
-          )
-        )
-      )
-    );
-    return combineLatest(actionStreams).pipe(
-      map((results) => {
-        results.sort((a, b) => a.index - b.index);
-        return results.map((r) => r.action);
-      })
-    );
-  };
-}
-function selectorMap(state$, ...selectors) {
-  return state$.pipe(
-    map((state) => {
-      return selectors.map((selector) => selector(state));
-    })
-  );
-}
-function selectorObject(state$, selectors) {
-  return state$.pipe(
-    map((state) => {
-      const result = {};
-      for (const [key, selector] of Object.entries(selectors)) {
-        result[key] = selector(state);
-      }
-      return result;
-    })
-  );
-}
-function validateMap({
-  validator,
-  apiCall
-}) {
-  return pipe(
-    switchMap((pipeData) => {
-      const callApi = () => apiCall(pipeData, {
-        chunkRequest: chunkRequestParallel,
-        chunkRequestConsistent
-      });
-      if (!validator) return callApi();
-      const validateConfig = validator(pipeData);
-      const { conditions, skipAction } = validateConfig;
-      const conditionMet = conditions.every(Boolean);
-      if (!conditionMet) {
-        if (Array.isArray(skipAction)) {
-          return of2(...skipAction?.filter(Boolean).map((action) => typeof action === "function" ? action() : action));
-        }
-        return of2(typeof skipAction === "function" ? skipAction() : skipAction);
-      }
-      return callApi();
-    })
-  );
-}
-var EffectsModule = class {
-  /**
-   * Создает модуль эффектов с доступом к состоянию, внешним состояниям и конфигурации
-   * @param storage Хранилище состояния
-   * @param externalStates Внешние состояния
-   * @param dispatchers Объект с диспетчерами
-   * @param services Объект с сервисами
-   * @param config Глобальная конфигурация для всех эффектов
-   */
-  constructor(storage, externalStates = {}, dispatchers, services = {}, config = {}) {
-    this.storage = storage;
-    this.externalStates = externalStates;
-    this.dispatchers = dispatchers;
-    this.services = services;
-    this.config = config;
-    this.subscribeToDispatchers();
-    this.state$ = new Observable4((observer) => {
-      this.storage.getState().then((state) => observer.next(state));
-      const unsubscribe = this.storage.subscribeToAll(() => {
-        this.storage.getState().then((state) => observer.next(state));
-      });
-      return () => unsubscribe();
-    }).pipe(share());
-  }
-  effects = [];
-  subscriptions = [];
-  running = false;
-  action$ = new Subject2();
-  /**
-   * Поток состояния
-   */
-  state$;
-  /**
-   * Подписывается на действия от всех диспетчеров
-   */
-  subscribeToDispatchers() {
-    for (const [_, dispatcher] of Object.entries(this.dispatchers)) {
-      const subscription = dispatcher.actions.subscribe((action) => {
-        this.action$.next(action);
-      });
-      this.subscriptions.push(subscription);
-    }
-  }
-  add(effect) {
-    this.effects.push(effect);
-    if (this.running) {
-      this.subscribeToEffect(effect);
-    }
-    return this;
-  }
-  /**
-   * Добавляет несколько эффектов
-   * @param effects Эффекты для добавления
-   * @returns Текущий модуль
-   */
-  addEffects(effects) {
-    effects.forEach((effect) => this.add(effect));
-    return this;
-  }
-  /**
-   * Запускает все эффекты
-   * @returns Текущий модуль
-   */
-  start() {
-    if (this.running) {
-      return this;
-    }
-    this.effects.forEach((effect) => this.subscribeToEffect(effect));
-    this.running = true;
-    return this;
-  }
-  /**
-   * Останавливает все эффекты
-   * @returns Текущий модуль
-   */
-  stop() {
-    this.subscriptions.forEach((sub) => sub.unsubscribe());
-    this.subscriptions = [];
-    this.running = false;
-    return this;
-  }
-  /**
-   * Подписывается на конкретный эффект
-   * @param effect Эффект для подписки
-   */
-  subscribeToEffect(effect) {
-    try {
-      const output$ = effect(this.action$.asObservable(), this.state$, this.externalStates, this.dispatchers, this.services, this.config).pipe(
-        catchError((err) => {
-          console.error("Error in effect:", err);
-          return of2(null);
-        })
-      );
-      const subscription = output$.subscribe((result) => {
-        if (result === null || result === void 0) {
-          return;
-        }
-        if (typeof result === "function") {
-          try {
-            result();
-          } catch (callError) {
-            console.error("Error calling effect result function:", callError);
-          }
-        }
-      });
-      this.subscriptions.push(subscription);
-    } catch (setupError) {
-      console.error("Error setting up effect:", setupError);
-    }
-  }
-};
-function createEffectBase(effect) {
-  return effect;
-}
-function createEffect(effect) {
-  return effect;
-}
-function combineEffects(...effects) {
-  return (action$, state$, externalStates, dispatchers, services, config) => {
-    const outputs = effects.map((effect) => {
-      try {
-        return effect(action$, state$, externalStates, dispatchers, services, config);
-      } catch (error) {
-        console.error("Error in one of combined effects:", error);
-        return of2(null);
-      }
-    });
-    return merge(...outputs);
-  };
-}
-export {
-  Dispatcher,
-  EffectsModule,
-  combineEffects,
-  createDispatcher,
-  createEffect,
-  createEffectBase,
-  loggerDispatcherMiddleware,
-  ofType,
-  ofTypes,
-  ofTypesWaitAll,
-  selectorMap,
-  selectorObject,
-  validateMap
-};
-//# sourceMappingURL=reactive.js.map
+export{a as Dispatcher,j as EffectsModule,m as combineEffects,b as createDispatcher,l as createEffect,k as createEffectBase,c as loggerDispatcherMiddleware,d as ofType,e as ofTypes,f as ofTypesWaitAll,g as selectorMap,h as selectorObject,i as validateMap}from'./chunk-IPUPRMZK.js';import'./chunk-5X65PSGD.js';