synapse-storage 3.0.1 → 3.0.3

package/dist/reactive.js

@@ -0,0 +1,604 @@
+// 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