@endge/utils 0.23.0

package/dist/utils.js

@@ -0,0 +1,1299 @@
+var L = Object.defineProperty;
+var C = (i, t, e) => t in i ? L(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e;
+var o = (i, t, e) => C(i, typeof t != "symbol" ? t + "" : t, e);
+import { ref as p, watch as w, triggerRef as D, reactive as _ } from "vue";
+import { parse as k, serialize as I } from "cookie-es";
+import { destr as z } from "destr";
+import { plainToInstance as y, instanceToPlain as g, Transform as f, TransformationType as h, Expose as N } from "class-transformer";
+import { IsOptional as P } from "class-validator";
+import "reflect-metadata";
+import R from "lodash/debounce.js";
+import { v4 as j } from "uuid";
+import { format as x, isAfter as T, isEqual as B, isBefore as A, startOfDay as m, endOfDay as U } from "date-fns";
+import { utcToZonedTime as $, getTimezoneOffset as b } from "date-fns-tz";
+import { defineStore as K } from "pinia";
+const H = {
+  path: "/",
+  watch: !0,
+  decode: (i) => z(decodeURIComponent(i)),
+  encode: (i) => encodeURIComponent(typeof i == "string" ? i : JSON.stringify(i))
+}, ct = (i, t) => {
+  var n;
+  const e = { ...H, ...t || {} }, r = k(document.cookie, e), s = p(r[i] ?? ((n = e.default) == null ? void 0 : n.call(e)));
+  return w(s, () => {
+    document.cookie = V(i, s.value, e);
+  }), s;
+};
+function V(i, t, e = {}) {
+  return t == null ? I(i, t, { ...e, maxAge: -1 }) : I(i, t, e);
+}
+var d = /* @__PURE__ */ ((i) => (i.Add = "add", i.Remove = "remove", i.Update = "update", i.IndexCreate = "indexCreate", i))(d || {});
+class O {
+  /**
+   * Создает экземпляр EventBus и подготавливает базовое состояние.
+   */
+  constructor(t) {
+    o(this, "listeners", /* @__PURE__ */ new Map());
+    t.forEach((e) => {
+      this.listeners.set(e, /* @__PURE__ */ new Set());
+    });
+  }
+  // ---- Типизированные события ----
+  /**
+   * Обрабатывает входящее событие EventBus.
+   */
+  on(t, e) {
+    this._on(t, e);
+  }
+  /**
+   * Обрабатывает входящее событие EventBus.
+   */
+  once(t, e) {
+    this._once(t, e);
+  }
+  /**
+   * Выполняет действие off в рамках ответственности EventBus.
+   */
+  off(t, e) {
+    this._off(t, e);
+  }
+  /**
+   * Выполняет действие offAll в рамках ответственности EventBus.
+   */
+  offAll() {
+    for (const t of this.listeners.values())
+      t.clear();
+  }
+  /**
+   * Публикует событие во внутренний event bus EventBus.
+   */
+  emit(t, e) {
+    this._emit(t, e);
+  }
+  // ---- Кастомные события (опционально) ----
+  /**
+   * Обрабатывает входящее событие EventBus.
+   */
+  onCustom(t, e) {
+    this._on(t, e);
+  }
+  /**
+   * Обрабатывает входящее событие EventBus.
+   */
+  onceCustom(t, e) {
+    this._once(t, e);
+  }
+  /**
+   * Выполняет действие offCustom в рамках ответственности EventBus.
+   */
+  offCustom(t, e) {
+    this._off(t, e);
+  }
+  /**
+   * Публикует событие во внутренний event bus EventBus.
+   */
+  emitCustom(t, e) {
+    this._emit(t, e);
+  }
+  // ---- Общая логика ----
+  /**
+   * Обрабатывает входящее событие EventBus.
+   */
+  _on(t, e) {
+    const r = Array.isArray(t) ? t : [t];
+    for (const s of r)
+      this.listeners.has(s) || this.listeners.set(s, /* @__PURE__ */ new Set()), this.listeners.get(s).add(e);
+  }
+  /**
+   * Обрабатывает входящее событие EventBus.
+   */
+  _once(t, e) {
+    const r = Array.isArray(t) ? t : [t], s = (n) => {
+      for (const a of r)
+        this.off(a, s);
+      e(n);
+    };
+    this._on(r, s);
+  }
+  /**
+   * Выполняет внутренний шаг _off для EventBus.
+   */
+  _off(t, e) {
+    var s;
+    const r = Array.isArray(t) ? t : [t];
+    for (const n of r)
+      (s = this.listeners.get(n)) == null || s.delete(e);
+  }
+  /**
+   * Публикует событие во внутренний event bus EventBus.
+   */
+  _emit(t, e) {
+    const r = this.listeners.get(t);
+    if (r)
+      for (const s of r)
+        s(e);
+  }
+  /**
+   * Выполняет действие hasListeners в рамках ответственности EventBus.
+   */
+  hasListeners(t) {
+    var e;
+    return (((e = this.listeners.get(t)) == null ? void 0 : e.size) ?? 0) > 0;
+  }
+  /**
+   * Выполняет действие eventNames в рамках ответственности EventBus.
+   */
+  eventNames() {
+    return [...this.listeners.entries()].filter(([, t]) => t.size > 0).map(([t]) => t);
+  }
+  /**
+   * Очищает накопленное состояние EventBus.
+   */
+  clear(t) {
+    var e;
+    t ? (e = this.listeners.get(t)) == null || e.clear() : this.listeners.clear();
+  }
+}
+const ft = new O(Object.keys({}));
+class E {
+  constructor() {
+    o(this, "subscribers", /* @__PURE__ */ new Set());
+  }
+  /**
+   * Подписывается на обновления.
+   * @param listener Функция, вызываемая при уведомлении.
+   * @returns Функция для отписки.
+   */
+  subscribe(t) {
+    return this.subscribers.add(t), () => {
+      this.subscribers.delete(t);
+    };
+  }
+  /**
+   * Уведомляет всех подписчиков.
+   */
+  notify() {
+    this.subscribers.forEach((t) => t());
+  }
+}
+const ut = (i) => {
+  const t = p(i), e = i.subscribe(() => {
+    D(t);
+  });
+  return { refObj: t, unsubscribe: e };
+};
+class ht extends E {
+  /**
+   * Создает экземпляр Collection и подготавливает базовое состояние.
+   */
+  constructor(e = []) {
+    super();
+    o(this, "items", []);
+    o(this, "indices", /* @__PURE__ */ new Map());
+    o(this, "rootIds", /* @__PURE__ */ new Set());
+    o(this, "bus");
+    this.bus = new O(Object.values(d)), e.length && this.add(e), this.createIndex("id");
+  }
+  /**
+   * Выполняет действие add в рамках ответственности Collection.
+   */
+  add(e) {
+    const r = Array.isArray(e) ? e : [e];
+    r.forEach((s) => {
+      this.items.push(s), this.indices.forEach((n, a) => {
+        n.set(s[a], s);
+      }), s.parentId || this.rootIds.add(s.id);
+    }), r != null && r.length && (this.bus.emit(d.Add, r), this.notify());
+  }
+  /**
+   * Удаляет сущность из runtime-коллекции Collection.
+   */
+  remove(e) {
+    const r = Array.isArray(e) ? e : [e], s = [];
+    r.forEach((n) => {
+      const a = typeof n == "string" ? n : n.id, c = this.items.findIndex((l) => l.id === a);
+      if (c !== -1) {
+        const [l] = this.items.splice(c, 1);
+        this.indices.forEach((u, M) => {
+          u.delete(l[M]);
+        }), l.parentId || this.rootIds.delete(l.id), s.push(l);
+      }
+    }), s.length && (this.bus.emit(d.Remove, s), this.notify());
+  }
+  /**
+   * Обновляет runtime-состояние Collection.
+   */
+  update(e) {
+    const r = Array.isArray(e) ? e : [e];
+    r.forEach((s) => {
+      const n = this.get(s.id);
+      n && (Object.assign(n, s), this.indices.forEach((a, c) => {
+        a.set(s[c], n);
+      }));
+    }), r != null && r.length && (this.bus.emit(d.Update, r), this.notify());
+  }
+  /**
+   * Возвращает значение состояния Collection.
+   */
+  get(e) {
+    if (typeof e == "string")
+      return this.indices.get("id").get(e);
+    {
+      const [r, s] = Object.entries(e)[0];
+      return this.indices.has(r) || this.createIndex(r), this.indices.get(r).get(s);
+    }
+  }
+  /**
+   * Создает runtime-сущность Collection.
+   */
+  createIndex(e) {
+    if (this.indices.has(e)) return;
+    const r = /* @__PURE__ */ new Map();
+    this.items.forEach((s) => {
+      r.set(s[e], s);
+    }), this.indices.set(e, r), this.bus.emit(d.IndexCreate, e);
+  }
+  /**
+   * Возвращает реактивный массив всех элементов.
+   */
+  get all() {
+    return this.items;
+  }
+  /**
+   * Возвращает массив корневых элементов (без parentId).
+   */
+  get allRoot() {
+    return Array.from(this.rootIds).map((e) => this.get(e));
+  }
+  // Доступ к подпискам
+  /**
+   * Обрабатывает входящее событие Collection.
+   */
+  on(e, r) {
+    this.bus.on(e, r);
+  }
+  /**
+   * Выполняет действие off в рамках ответственности Collection.
+   */
+  off(e, r) {
+    this.bus.off(e, r);
+  }
+}
+class dt {
+  /**
+   * Создает экземпляр IndexedCollection и подготавливает базовое состояние.
+   */
+  constructor(t = null) {
+    o(this, "list", []);
+    o(this, "filteredList", []);
+    o(this, "map", /* @__PURE__ */ new Map());
+    o(this, "indexById", /* @__PURE__ */ new Map());
+    o(this, "dirtySort", !1);
+    o(this, "dirtyFilter", !1);
+    o(this, "sortFn");
+    o(this, "filterFn");
+    o(this, "indexEnabled", !1);
+    o(this, "filterIndexEnabled", !1);
+    t && this.options(t);
+  }
+  /**
+   * Выполняет действие options в рамках ответственности IndexedCollection.
+   */
+  options(t) {
+    return Object.prototype.hasOwnProperty.call(t, "sortFn") && (this.sortFn = t.sortFn, this.dirtySort = !0), Object.prototype.hasOwnProperty.call(t, "filterFn") && (this.filterFn = t.filterFn, this.dirtyFilter = !0), t.indexEnabled !== void 0 && (this.indexEnabled = t.indexEnabled, this.dirtySort = !0), t.filterIndexEnabled !== void 0 && (this.filterIndexEnabled = t.filterIndexEnabled, this.dirtyFilter = !0), this;
+  }
+  /**
+   * Выполняет действие markDirty в рамках ответственности IndexedCollection.
+   */
+  markDirty(t) {
+    t.sort && (this.dirtySort = !0), t.filter && (this.dirtyFilter = !0);
+  }
+  /**
+   * Выполняет действие ensure в рамках ответственности IndexedCollection.
+   */
+  ensure() {
+    this.ensureSorted(), this.ensureFiltered();
+  }
+  // Сортировка list, если нужно
+  /**
+   * Выполняет действие ensureSorted в рамках ответственности IndexedCollection.
+   */
+  ensureSorted() {
+    if (this.dirtySort) {
+      this.sortFn && this.list.sort(this.sortFn), this.indexById.clear();
+      for (let t = 0; t < this.list.length; t++) {
+        const e = this.list[t];
+        this.indexById.set(e.id, t), this.indexEnabled && (e.index = t);
+      }
+      this.filterFn && (this.dirtyFilter = !0), this.dirtySort = !1;
+    }
+  }
+  // Фильтр, если нужно
+  /**
+   * Выполняет действие ensureFiltered в рамках ответственности IndexedCollection.
+   */
+  ensureFiltered() {
+    this.dirtyFilter && (this.rebuildFilteredFromScratch(), this.dirtyFilter = !1);
+  }
+  /**
+   * Выполняет действие add в рамках ответственности IndexedCollection.
+   */
+  add(t) {
+    const e = Array.isArray(t) ? t : [t];
+    for (const r of e) {
+      if (this.map.has(r.id)) continue;
+      const s = this.list.length;
+      this.list.push(r), this.map.set(r.id, r), this.indexById.set(r.id, s), this.indexEnabled && (r.index = s), this.filterIndexEnabled && (r.filteredIndex = -1), this.addToFilteredIfPasses(r);
+    }
+    this.sortFn && (this.dirtySort = !0);
+  }
+  /**
+   * Удаляет сущность из runtime-коллекции IndexedCollection.
+   */
+  remove(t) {
+    const e = Array.isArray(t) ? t : [t];
+    for (const r of e) {
+      const s = this.map.get(r);
+      s && (this.removeFromFilteredO1(s), this.removeFromListO1(r), this.map.delete(r), this.indexEnabled && (s.index = -1), this.filterIndexEnabled && (s.filteredIndex = -1));
+    }
+    this.sortFn && (this.dirtySort = !0);
+  }
+  /**
+   * Вызывать после изменения полей элемента
+   * mayAffectFilter если изменились поля фильтра
+   * mayAffectSort если изменились поля сортировки
+   */
+  touch(t, e = {}) {
+    const r = this.map.get(t);
+    r && (e.mayAffectFilter !== !1 && (this.refilterOneO1(r), !this.filterIndexEnabled && this.filterFn && (this.dirtyFilter = !0)), e.mayAffectSort !== !1 && this.sortFn && (this.dirtySort = !0));
+  }
+  /**
+   * Выполняет действие forEach в рамках ответственности IndexedCollection.
+   */
+  forEach(t) {
+    this.ensure();
+    const e = this.filterFn ? this.filteredList : this.list;
+    for (let r = 0; r < e.length; r++)
+      t(e[r], r);
+  }
+  /**
+   * Отсортированный и/или отфильтрованный список (в зависимости от включенных функций).
+   */
+  all() {
+    return this.filtered();
+  }
+  /**
+   * Отсортированный полный список (без фильтра), если есть sortFn.
+   */
+  unfiltered() {
+    return this.ensureSorted(), this.list;
+  }
+  /**
+   * Отсортированный и отфильтрованный список (если есть filterFn).
+   * Если filterFn нет — возвращается list.
+   */
+  filtered() {
+    return this.ensure(), this.filterFn ? this.filteredList : this.list;
+  }
+  /**
+   * Выполняет действие pos в рамках ответственности IndexedCollection.
+   */
+  pos(t) {
+    const e = this.all();
+    return t < 0 || t >= e.length ? null : e[t] ?? null;
+  }
+  /**
+   * Выполняет действие first в рамках ответственности IndexedCollection.
+   */
+  first() {
+    const t = this.all();
+    return t.length ? t[0] ?? null : null;
+  }
+  /**
+   * Выполняет действие last в рамках ответственности IndexedCollection.
+   */
+  last() {
+    const t = this.all();
+    return t.length ? t[t.length - 1] ?? null : null;
+  }
+  /**
+   * Выполняет действие has в рамках ответственности IndexedCollection.
+   */
+  has(t) {
+    return this.map.has(t);
+  }
+  /**
+   * Возвращает значение состояния IndexedCollection.
+   */
+  get(t) {
+    return this.map.get(t);
+  }
+  /**
+   * Выполняет действие size в рамках ответственности IndexedCollection.
+   */
+  size() {
+    return this.all().length;
+  }
+  /**
+   * Очищает накопленное состояние IndexedCollection.
+   */
+  clear() {
+    this.list = [], this.filteredList = [], this.map.clear(), this.indexById.clear(), this.dirtySort = !1, this.dirtyFilter = !1;
+  }
+  /**
+   * Выполняет внутренний шаг rebuildFilteredFromScratch для IndexedCollection.
+   */
+  rebuildFilteredFromScratch() {
+    if (!this.filterFn) {
+      if (this.filteredList = [], this.filterIndexEnabled)
+        for (const t of this.list) t.filteredIndex = -1;
+      return;
+    }
+    if (this.filteredList = [], this.filterIndexEnabled)
+      for (const t of this.list) t.filteredIndex = -1;
+    for (const t of this.list)
+      this.filterFn(t) && this.appendToFiltered(t);
+  }
+  /**
+   * Выполняет внутренний шаг addToFilteredIfPasses для IndexedCollection.
+   */
+  addToFilteredIfPasses(t) {
+    if (this.filterFn) {
+      if (!this.filterIndexEnabled) {
+        this.dirtyFilter = !0;
+        return;
+      }
+      (t.filteredIndex ?? -1) >= 0 || this.filterFn(t) && this.appendToFiltered(t);
+    }
+  }
+  /**
+   * Добавляет сущность в runtime-коллекцию IndexedCollection.
+   */
+  appendToFiltered(t) {
+    const e = this.filteredList.length;
+    this.filteredList.push(t), this.filterIndexEnabled && (t.filteredIndex = e);
+  }
+  /**
+   * Выполняет внутренний шаг refilterOneO1 для IndexedCollection.
+   */
+  refilterOneO1(t) {
+    if (!this.filterFn || !this.filterIndexEnabled) return !1;
+    const e = this.filterFn(t), s = (t.filteredIndex ?? -1) >= 0;
+    return e ? s ? !1 : (this.appendToFiltered(t), !0) : s ? (this.removeFromFilteredO1(t), !0) : !1;
+  }
+  /**
+   * Удаляет сущность из runtime-коллекции IndexedCollection.
+   */
+  removeFromFilteredO1(t) {
+    if (!this.filterIndexEnabled) return;
+    const e = t.filteredIndex ?? -1;
+    if (e < 0) return;
+    const r = this.filteredList.length - 1;
+    if (e !== r) {
+      const s = this.filteredList[r];
+      this.filteredList[e] = s, s.filteredIndex = e;
+    }
+    this.filteredList.pop(), t.filteredIndex = -1;
+  }
+  /**
+   * Удаляет сущность из runtime-коллекции IndexedCollection.
+   */
+  removeFromListO1(t) {
+    const e = this.indexById.get(t);
+    if (e === void 0) return;
+    const r = this.list.length - 1;
+    if (e !== r) {
+      const s = this.list[r];
+      this.list[e] = s, this.indexById.set(s.id, e), this.indexEnabled && (s.index = e);
+    }
+    this.list.pop(), this.indexById.delete(t);
+  }
+}
+class mt {
+  /**
+   * Создает экземпляр DelayedExecutor и подготавливает базовое состояние.
+   */
+  constructor(t, e = !1) {
+    o(this, "delayTimer", null);
+    o(this, "maxTimer", null);
+    o(this, "hasExecutedOnce", !1);
+    o(this, "lastArgs", null);
+    this.fn = t, this.firstExecuteImmediately = e;
+  }
+  /**
+   * Выполняет действие run в рамках ответственности DelayedExecutor.
+   */
+  run(t, e = 500, r = 2e3) {
+    if (this.lastArgs = t, this.firstExecuteImmediately && !this.hasExecutedOnce) {
+      this.hasExecutedOnce = !0, this.flush();
+      return;
+    }
+    this.delayTimer && clearTimeout(this.delayTimer), this.delayTimer = setTimeout(() => this.flush(), e), this.maxTimer || (this.maxTimer = setTimeout(() => this.flush(), r));
+  }
+  /**
+   * Принудительно завершает накопленные изменения DelayedExecutor.
+   */
+  flush() {
+    this.clear(), this.lastArgs && this.fn(...this.lastArgs);
+  }
+  /**
+   * Выполняет действие cancel в рамках ответственности DelayedExecutor.
+   */
+  cancel() {
+    this.clear();
+  }
+  /**
+   * Очищает накопленное состояние DelayedExecutor.
+   */
+  clear() {
+    this.delayTimer && clearTimeout(this.delayTimer), this.maxTimer && clearTimeout(this.maxTimer), this.delayTimer = null, this.maxTimer = null;
+  }
+}
+class pt {
+  /**
+   * Создает экземпляр NamedExecutor и подготавливает базовое состояние.
+   */
+  constructor(t) {
+    o(this, "delayTimers", /* @__PURE__ */ new Map());
+    o(this, "maxTimers", /* @__PURE__ */ new Map());
+    o(this, "callbacks", /* @__PURE__ */ new Map());
+    o(this, "firstCallTime", /* @__PURE__ */ new Map());
+    this.config = t;
+  }
+  /**
+   * Выполняет действие run в рамках ответственности NamedExecutor.
+   */
+  run(t, e) {
+    const r = Date.now();
+    if (!this.firstCallTime.has(t)) {
+      this.firstCallTime.set(t, r);
+      const n = setTimeout(() => {
+        this.flush(t);
+      }, this.config.maxMs);
+      this.maxTimers.set(t, n);
+    }
+    this.callbacks.set(t, e), clearTimeout(this.delayTimers.get(t));
+    const s = setTimeout(() => {
+      this.flush(t);
+    }, this.config.delayMs);
+    this.delayTimers.set(t, s);
+  }
+  /**
+   * Принудительно завершает накопленные изменения NamedExecutor.
+   */
+  flush(t) {
+    try {
+      const e = this.callbacks.get(t);
+      e && e();
+    } catch (e) {
+      console.error("[NamedExecutor] flush error:", e);
+    }
+    this.clear(t);
+  }
+  /**
+   * Выполняет действие cancel в рамках ответственности NamedExecutor.
+   */
+  cancel(t) {
+    this.clear(t);
+  }
+  /**
+   * Принудительно завершает накопленные изменения NamedExecutor.
+   */
+  flushAll() {
+    for (const t of this.callbacks.keys())
+      this.flush(t);
+  }
+  /**
+   * Очищает накопленное состояние NamedExecutor.
+   */
+  clear(t) {
+    clearTimeout(this.delayTimers.get(t)), clearTimeout(this.maxTimers.get(t)), this.delayTimers.delete(t), this.maxTimers.delete(t), this.callbacks.delete(t), this.firstCallTime.delete(t);
+  }
+}
+function yt(i, t) {
+  return y(i, t, {
+    exposeDefaultValues: !0,
+    excludeExtraneousValues: !0
+  });
+}
+function gt(i) {
+  return g(i, {
+    exposeUnsetFields: !1
+  });
+}
+function xt(i) {
+  return function(t, e) {
+    N(i)(t, e), Reflect.defineMetadata("genericExpose", i.name, t, e);
+  };
+}
+const J = Symbol("beforeSerialize");
+function bt() {
+  return function(i, t, e) {
+    Reflect.defineMetadata(J, t, i);
+  };
+}
+function Tt(i, t, e) {
+  i.__afterDeserializeMethods__ || (i.__afterDeserializeMethods__ = []), i.__afterDeserializeMethods__.push(t);
+}
+function It(i) {
+  return function(t, e) {
+    f(({ value: r }) => r === null ? void 0 : r, { toPlainOnly: !0 })(t, e), P(i)(t, e);
+  };
+}
+function St() {
+  return f(({ value: i, type: t }) => t === h.PLAIN_TO_CLASS ? i == null ? void 0 : i.id : i);
+}
+function wt(i) {
+  return f(({ value: t, type: e }) => e === h.PLAIN_TO_CLASS ? t == null ? void 0 : t.map((r) => r == null ? void 0 : r[i]) : t);
+}
+function At() {
+  return f(({ value: i, type: t }) => t === h.CLASS_TO_PLAIN && (i == null ? void 0 : i.id) || i);
+}
+function Ot() {
+  return f(({ value: i, type: t }) => t === h.CLASS_TO_PLAIN ? i.map((e) => e.id) : i);
+}
+function Et() {
+  return f(({ value: i, type: t }) => t === "classToPlain" ? void 0 : i, { toPlainOnly: !0 });
+}
+function Ft(i) {
+  return i == null;
+}
+const F = Symbol("onDeserialized");
+function Mt() {
+  return function(i, t) {
+    Reflect.defineMetadata(F, t, i);
+  };
+}
+function Z(i) {
+  const t = Reflect.getMetadata(
+    F,
+    i
+  );
+  return t ? i[t].bind(i) : null;
+}
+class Lt {
+  /**
+   * Выполняет действие toPlain в рамках ответственности Serialize.
+   */
+  static toPlain(t) {
+    return g(t, {
+      exposeDefaultValues: !0,
+      excludeExtraneousValues: !0
+    });
+  }
+  /**
+   * Выполняет действие fromJSON в рамках ответственности Serialize.
+   */
+  static fromJSON(t, e) {
+    const r = y(t, e, {
+      exposeDefaultValues: !0,
+      excludeExtraneousValues: !0
+    }), s = Z(r);
+    return s && s(), r;
+  }
+}
+function Ct() {
+  return function(i, t) {
+    f(
+      ({ value: e }) => {
+        if (typeof e == "string")
+          try {
+            return JSON.parse(e);
+          } catch {
+            return {};
+          }
+        return e;
+      },
+      { toClassOnly: !0 }
+    )(i, t), f(
+      ({ value: e }) => {
+        try {
+          return JSON.stringify(e);
+        } catch {
+          return "{}";
+        }
+      },
+      { toPlainOnly: !0 }
+    )(i, t);
+  };
+}
+function Dt() {
+  return function(i, t) {
+    f(
+      ({ value: e }) => typeof e == "string" ? e.trim() : String(e ?? ""),
+      { toClassOnly: !0 }
+    )(i, t), f(
+      ({ value: e }) => typeof e == "string" ? e : String(e ?? ""),
+      { toPlainOnly: !0 }
+    )(i, t);
+  };
+}
+function _t(i, t) {
+  return f(({ value: e, type: r }) => e ? r === h.PLAIN_TO_CLASS ? Array.isArray(e) ? t ? new Map(
+    e.map((s) => {
+      const n = y(i, s);
+      return [n[t], n];
+    })
+  ) : (console.warn(
+    "[TypeMap] Key field is required for array transformation!"
+  ), /* @__PURE__ */ new Map()) : typeof e == "object" ? new Map(
+    Object.entries(e).map(([s, n]) => {
+      const a = new i();
+      return Object.assign(a, n), [s, a];
+    })
+  ) : (console.warn("[TypeMap] Expected object or array, got:", e), /* @__PURE__ */ new Map()) : r === h.CLASS_TO_PLAIN ? e instanceof Map ? Array.from(e.values()).map((s) => g(s)) : (console.warn("[TypeMap] Expected Map, got:", e), t ? [] : {}) : (console.warn("[TypeMap] Unexpected transformation type:", r), e) : /* @__PURE__ */ new Map());
+}
+function kt(i) {
+  return f(({ value: t, type: e }) => {
+    if (!t || typeof t != "object") return {};
+    if (e === h.PLAIN_TO_CLASS) {
+      const r = {};
+      for (const s of Object.keys(t))
+        r[s] = y(i, t[s]);
+      return r;
+    }
+    if (e === h.CLASS_TO_PLAIN) {
+      const r = {};
+      for (const s of Object.keys(t))
+        r[s] = g(t[s]);
+      return r;
+    }
+    return t;
+  });
+}
+function zt(i, t, e = (n) => n, r = (n) => n, s = 300) {
+  let n = t;
+  const a = localStorage.getItem(i);
+  if (a)
+    try {
+      const u = JSON.parse(a);
+      n = e(u);
+    } catch {
+      console.error("Failed to parse from localStorage", i, a);
+    }
+  const c = p(n), l = R(() => {
+    try {
+      const u = JSON.stringify(r(c.value));
+      localStorage.setItem(i, u);
+    } catch {
+      console.error("Failed to save to localStorage", i, c.value);
+    }
+  }, s);
+  return w(
+    () => c.value,
+    () => {
+      l();
+    },
+    { deep: !0 }
+  ), c;
+}
+function Nt(i, t) {
+  return i < t ? -1 : i > t ? 1 : 0;
+}
+const q = process.env.NODE_ENV !== "production";
+function Pt(i, t) {
+  if (!q) return t();
+  console.groupCollapsed(`⏳ ${i}`);
+  const e = performance.now(), r = t(), s = performance.now();
+  return console.log(`${i}: ${Math.round(s - e)} ms`), console.groupEnd(), r;
+}
+const Rt = () => j(), S = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function jt(i) {
+  let t = "";
+  for (let e = 0; e < i; ++e)
+    t += S[Math.floor(S.length * Math.random())];
+  return t;
+}
+class Bt {
+  /**
+   * Создает экземпляр HotkeyManager и подготавливает базовое состояние.
+   */
+  constructor(t = {}) {
+    o(this, "bindings", /* @__PURE__ */ new Map());
+    o(this, "enabled", !0);
+    o(this, "target");
+    o(this, "ignoreInput");
+    o(this, "handleBound");
+    this.target = t.target || window, this.ignoreInput = t.ignoreInput ?? !1, this.handleBound = this.handle.bind(this), this.target.addEventListener("keydown", this.handleBound);
+  }
+  /**
+   * Выполняет внутренний шаг isIgnoredTarget для HotkeyManager.
+   */
+  isIgnoredTarget(t) {
+    return this.ignoreInput ? t instanceof HTMLInputElement || t instanceof HTMLTextAreaElement || t instanceof HTMLElement && t.isContentEditable : !1;
+  }
+  /**
+   * Нормализует входные данные HotkeyManager.
+   */
+  normalizeKey(t) {
+    const e = [];
+    return t.ctrlKey && e.push("ctrl"), t.metaKey && e.push("meta"), t.altKey && e.push("alt"), t.shiftKey && e.push("shift"), e.push(t.key.toLowerCase()), e.join("+");
+  }
+  /**
+   * Обрабатывает runtime-событие HotkeyManager.
+   */
+  handle(t) {
+    if (!this.enabled || this.isIgnoredTarget(t.target)) return;
+    const e = this.normalizeKey(t), r = this.bindings.get(e);
+    if (r)
+      for (const s of r)
+        s(t);
+  }
+  /**
+   * Обрабатывает входящее событие HotkeyManager.
+   */
+  on(t, e) {
+    const r = Array.isArray(t) ? t : [t];
+    for (const s of r) {
+      const n = s.toLowerCase();
+      this.bindings.has(n) || this.bindings.set(n, /* @__PURE__ */ new Set()), this.bindings.get(n).add(e);
+    }
+  }
+  /**
+   * Выполняет действие off в рамках ответственности HotkeyManager.
+   */
+  off(t, e) {
+    var s;
+    const r = Array.isArray(t) ? t : [t];
+    for (const n of r) {
+      const a = n.toLowerCase();
+      (s = this.bindings.get(a)) == null || s.delete(e);
+    }
+  }
+  /**
+   * Очищает накопленное состояние HotkeyManager.
+   */
+  clear(t) {
+    t ? this.bindings.delete(t.toLowerCase()) : this.bindings.clear();
+  }
+  /**
+   * Выполняет действие enable в рамках ответственности HotkeyManager.
+   */
+  enable() {
+    this.enabled = !0;
+  }
+  /**
+   * Выполняет действие disable в рамках ответственности HotkeyManager.
+   */
+  disable() {
+    this.enabled = !1;
+  }
+  /**
+   * Освобождает runtime-ресурсы и подписки HotkeyManager.
+   */
+  destroy() {
+    this.clear(), this.target.removeEventListener("keydown", this.handleBound);
+  }
+}
+function Ut(i, t) {
+  return t != null && t.key ? i.some((e) => {
+    var l, u;
+    const r = e.ctrl === void 0 || t.ctrlKey === e.ctrl, s = e.alt === void 0 || t.altKey === e.alt, n = e.shift === void 0 || t.shiftKey === e.shift, a = e.meta === void 0 || t.metaKey === e.meta, c = t.key && e.key && ((l = t.key) == null ? void 0 : l.toLowerCase()) === ((u = e.key) == null ? void 0 : u.toLowerCase());
+    return r && s && n && a && c;
+  }) : !1;
+}
+class $t extends E {
+  constructor() {
+    super(...arguments);
+    /** Массив всех логов */
+    o(this, "logs", []);
+    /** Текущий контекст (иерархия) */
+    o(this, "currentContext", []);
+    o(this, "currentActions", []);
+  }
+  /**
+   * Устанавливает текущий контекст.
+   * Сбрасывает предыдущий контекст.
+   *
+   * @param context Массив строк или несколько строк с уровнями контекста.
+   * @returns _surface (для цепочки вызовов)
+   * @example
+   * logger.context('components', 'DriverCard')
+   */
+  context(...e) {
+    return this.currentContext = e, this;
+  }
+  /**
+   * Добавляет дополнительный уровень контекста.
+   *
+   * @param context Новый уровень (например, 'attributes').
+   * @returns _surface (для цепочки вызовов)
+   * @example
+   * logger.start('attributes')
+   */
+  start(e) {
+    return this.currentContext.push(e), this;
+  }
+  /**
+   * Убирает последний уровень контекста.
+   * При этом может сразу добавить финальный лог, связанный с этим контекстом.
+   *
+   * @param level Уровень лога (по умолчанию 'info')
+   * @param message Сообщение лога (опционально)
+   * @param actions Дополнительные действия (опционально)
+   * @example
+   * logger.end('info', 'Компиляция завершена', [...])
+   */
+  end(e, r, s) {
+    if (r) {
+      const n = s ?? this.currentActions.length ? this.currentActions : void 0;
+      this.log(e ?? "info", r, n);
+    }
+    return this.currentContext.pop(), this.currentActions = [], this;
+  }
+  /**
+   * Добавляет экшены в текущий контекст (для следующего `end`)
+   * @param icon Иконка (например, "ti ti-check text-xl")
+   * @param tooltip Подсказка (опционально)
+   * @param handler Функция при клике (опционально)
+   * @example
+   * logger.action('ti ti-check', 'Все успешно', () => console.logFrame('Успешно!'))
+   */
+  action(e, r, s) {
+    return this.currentActions.push({ icon: e, tooltip: r, handler: s }), this;
+  }
+  /**
+   * Внутренний метод для создания лога.
+   *
+   * @param level Уровень (_debug, info, warn, error)
+   * @param message Сообщение
+   * @param actions Дополнительные действия (иконки с обработчиками)
+   */
+  log(e, r, s) {
+    const n = {
+      timestamp: Date.now(),
+      level: e,
+      message: r,
+      context: [...this.currentContext],
+      actions: s
+    };
+    this.logs.push(n), this.notify();
+  }
+  /**
+   * Лог уровня _debug.
+   *
+   * @param message Сообщение
+   * @param actions Дополнительные действия (опционально)
+   * @example
+   * logger._debug('Загрузка данных')
+   */
+  debug(e, r) {
+    this.log("debug", e, r);
+  }
+  /**
+   * Лог уровня info.
+   *
+   * @param message Сообщение
+   * @param actions Дополнительные действия (опционально)
+   * @example
+   * logger.info('Загрузка завершена')
+   */
+  info(e, r) {
+    this.log("info", e, r);
+  }
+  /**
+   * Лог уровня warn.
+   *
+   * @param message Сообщение
+   * @param actions Дополнительные действия (опционально)
+   * @example
+   * logger.warn('Низкий заряд батареи')
+   */
+  warn(e, r) {
+    this.log("warn", e, r);
+  }
+  /**
+   * Лог уровня error.
+   *
+   * @param message Сообщение
+   * @param actions Дополнительные действия (опционально)
+   * @example
+   * logger.error('Ошибка загрузки', [
+   *   { icon: 'ti ti-refresh', tooltip: 'Повторить', handler: () => retry() },
+   * ])
+   */
+  error(e, r) {
+    this.log("error", e, r);
+  }
+  /**
+   * Лог уровня success.
+   *
+   * @param message Сообщение
+   * @param actions Дополнительные действия (опционально)
+   * @example
+   * logger.success('Успешно', [
+   *   { icon: 'ti ti-refresh', tooltip: 'Повторить', handler: () => retry() },
+   * ])
+   */
+  success(e, r) {
+    this.log("success", e, r);
+  }
+  /**
+   * Получить все логи.
+   *
+   * @returns Массив логов
+   */
+  getLogs() {
+    return this.logs;
+  }
+  /**
+   * Очистить все логи (полностью).
+   */
+  clear() {
+    this.logs = [], this.notify();
+  }
+}
+function W(i) {
+  try {
+    return new new Proxy(i, { construct: () => ({}) })(), !0;
+  } catch {
+    return !1;
+  }
+}
+function Kt(i, ...t) {
+  if (W(i)) {
+    const e = i;
+    return new e(...t);
+  } else
+    return i(...t);
+}
+class Ht {
+  /**
+   * Создает экземпляр ScriptRunner и подготавливает базовое состояние.
+   */
+  constructor(t) {
+    this.script = t;
+  }
+  /**
+   * Запускает скрипт с некоторым контекстом и автоматически
+   * добавляют экспортируемые имена которые парсятся из JSX
+   */
+  async runAsync(t, e = /* @__PURE__ */ new Set()) {
+    const r = Object.keys(t), s = Object.fromEntries(
+      r.map((u) => [u, this.wrapIfAsync(t[u])])
+    ), n = Array.from(e), a = n.length > 0 ? `
+
+expose({ ${n.join(", ")} });
+` : "", c = `${this.script}${a}`;
+    return await new Function(
+      ...r,
+      `"use strict"; return (async () => { ${c} })();`
+    )(...Object.values(s));
+  }
+  /**
+   * Синхронно вычисляет выражение в контексте.
+   * Используется для интерполяций, :bind, v-if и т.п.
+   */
+  runSync(t, e = /* @__PURE__ */ new Set()) {
+    const r = Object.keys(t), s = Object.values(t), n = Array.from(e), a = n.length > 0 ? `
+
+expose({ ${n.join(", ")} });
+` : "";
+    try {
+      new Function(
+        ...r,
+        `"use strict"; ${this.script}${a};`
+      )(...s);
+    } catch (c) {
+      console.warn(
+        "(ScriptRunner.runSync): Ошибка в выражении:",
+        this.script,
+        c
+      );
+    }
+  }
+  /**
+   * Синхронно вычисляет выражение в контексте.
+   * Используется для интерполяций, :bind, v-if и т.п.
+   */
+  evaluate(t) {
+    const e = Object.keys(t), r = Object.values(t);
+    console.log(t);
+    try {
+      return new Function(
+        ...e,
+        `"use strict"; return (${this.script});`
+      )(...r);
+    } catch (s) {
+      console.warn(
+        "(ScriptRunner.runSync): Ошибка в выражении:",
+        this.script,
+        s
+      );
+      return;
+    }
+  }
+  /**
+   * Выполняет внутренний шаг wrapIfAsync для ScriptRunner.
+   */
+  wrapIfAsync(t) {
+    if (typeof t != "object" || t === null) return t;
+    const e = {};
+    for (const [r, s] of Object.entries(t))
+      typeof s == "function" ? e[r] = (...n) => {
+        const a = s(...n);
+        return a instanceof Promise, a;
+      } : e[r] = s;
+    return e;
+  }
+}
+const Y = /* @__PURE__ */ new WeakMap();
+function Vt(i) {
+  let t;
+  return () => (t || (t = i(), Y.set(i, t)), t);
+}
+function Jt(i) {
+  return String(i).charAt(0).toUpperCase() + String(i).slice(1);
+}
+function Zt(i, t) {
+  return T(i, t) || B(i, t);
+}
+function qt(i, t, e, r) {
+  const s = m(i), n = m(t), a = m(e), c = m(r);
+  return !A(n, a) && !T(s, c);
+}
+function Wt(i, t, e) {
+  return !A(i, m(t)) && !T(i, U(e));
+}
+const Yt = (i) => i && new Date(i);
+function Gt(i, t = "HH:mm dd.MM.yyyy", e = {}) {
+  return i && x(i, t, e);
+}
+function G(i, t = "HH:mm dd.MM.yyyy", e = {}, r = !0) {
+  if (!i || !i || i === "")
+    return "";
+  if (typeof i == "string")
+    i = new Date(i);
+  else if (i instanceof Date) {
+    if (isNaN(i))
+      return "";
+  } else
+    i = new Date(i.toString());
+  return r ? x(i, t, e) : x($(i, "utc"), t, e);
+}
+function Qt(i) {
+  const t = { weekday: "short" }, e = new Intl.DateTimeFormat("ru-RU", t).format(i);
+  return e.charAt(0).toUpperCase() + e.slice(1);
+}
+function Xt(i) {
+  const t = new Date(i), e = t.getTime() + t.getTimezoneOffset() * 6e3, r = new Date(e + 180 * 6e3), s = String(r.getDate()).padStart(2, "0"), n = String(r.getMonth() + 1).padStart(2, "0"), a = r.getFullYear();
+  return `${s}.${n}.${a}`;
+}
+function vt(i, t = !0) {
+  return G(i, "HH:mm", {}, t);
+}
+function te(i) {
+  const t = Array.from(i), e = Math.min(...t.map((s) => s.getTime())), r = Math.max(...t.map((s) => s.getTime()));
+  return {
+    minDate: new Date(e),
+    maxDate: new Date(r)
+  };
+}
+function ee(i) {
+  const t = /* @__PURE__ */ new Date();
+  try {
+    const e = b(i, t), r = Intl.supportedValuesOf("timeZone");
+    for (const s of r)
+      if (b(s, t) === e)
+        return s;
+  } catch {
+    return null;
+  }
+  return null;
+}
+function ie(i) {
+  return b(i, /* @__PURE__ */ new Date());
+}
+const re = K("tooltip", () => {
+  const i = _({}), t = p(null);
+  function e(l) {
+    i[l.id] = {
+      ...l,
+      visible: !1
+    };
+  }
+  function r(l) {
+    delete i[l];
+  }
+  function s(l) {
+    i[l] && (t.value = l, i[l].active = !0);
+  }
+  function n(l) {
+    i[l] && (i[l].active = !1, t.value === l && (t.value = null));
+  }
+  function a(l) {
+    s(l);
+  }
+  function c() {
+    t.value && n(t.value);
+  }
+  return {
+    tooltips: i,
+    activeId: t,
+    registerTooltip: e,
+    unregisterTooltip: r,
+    showTooltip: s,
+    hideTooltip: n,
+    setActiveTooltipId: a,
+    clearActiveTooltipId: c
+  };
+}), se = "x-collection-tooltip-id";
+export {
+  Tt as AfterDeserialize,
+  ft as AppBus,
+  bt as BeforeSerialize,
+  ht as Collection,
+  mt as DelayedExecutor,
+  wt as DeserializeArrayField,
+  St as DeserializeId,
+  O as EventBus,
+  d as Events,
+  xt as GenericExpose,
+  Bt as HotkeyManager,
+  q as IS_DEBUG,
+  Et as IgnoreToPlain,
+  dt as IndexedCollection,
+  It as IsOptionalTransformed,
+  Ct as Json,
+  pt as NamedExecutor,
+  Dt as Script,
+  Ht as ScriptRunner,
+  Lt as Serialize,
+  At as SerializeId,
+  Ot as SerializeIds,
+  $t as StructuredLogger,
+  E as Subscribable,
+  se as TooltipAttribute,
+  _t as TypeMap,
+  kt as TypeRecord,
+  Jt as capitalize,
+  Nt as compareNumber,
+  Kt as createInstance,
+  vt as extractTime,
+  te as findMinMaxDates,
+  Xt as formatDateToMSK,
+  Gt as formatDatetime,
+  G as formatDatetimeTZ,
+  Rt as generateUUID,
+  Qt as getDayOfWeek,
+  Z as getOnDeserializedMethod,
+  ie as getTimezoneOffsetMs,
+  Vt as globalState,
+  Zt as isAfterOrEqual,
+  Ut as isAnyKeyComboActive,
+  W as isConstructor,
+  Wt as isDateInRange,
+  qt as isDateRangeOverlap,
+  Ft as isNullOrUndefined,
+  Mt as onDeserialized,
+  Yt as parseDate,
+  ee as parseOffsetToTimezone,
+  Pt as profile,
+  jt as randomString,
+  yt as toInstance,
+  gt as toPlain,
+  ct as useCookie,
+  zt as useStorageDebounced,
+  ut as useSubscribableRef,
+  re as useTooltipStore
+};