r3ui-lib 1.3.19 → 1.3.21

package/dist/modules/utils/tableAdapter.js

@@ -0,0 +1,156 @@
+import { trackTableLoad as p } from "./tableLoad.js";
+function b(a) {
+  const e = /* @__PURE__ */ new Set();
+  return a.flatMap((t) => {
+    if (t.field === void 0) return [];
+    if (typeof t.field != "string" || !t.field.trim() || e.has(t.field) || t.title !== void 0 && typeof t.title != "string" || t.visible !== void 0 && typeof t.visible != "boolean")
+      throw new TypeError("Некорректная колонка редактора таблицы");
+    return e.add(t.field), [
+      {
+        ...t,
+        field: t.field,
+        title: t.title ?? "",
+        visible: t.visible !== !1
+      }
+    ];
+  });
+}
+function n(a) {
+  return a.flatMap((e) => {
+    if (e.field === void 0) return [];
+    if (typeof e.field != "string" || !e.field.trim())
+      throw new TypeError("Некорректное поле колонки снимка таблицы");
+    if (e.width != null && (typeof e.width != "number" || !Number.isFinite(e.width) || e.width < 0))
+      throw new TypeError("Некорректная ширина колонки снимка таблицы");
+    if (e.visible !== void 0 && typeof e.visible != "boolean")
+      throw new TypeError("Некорректная видимость колонки снимка таблицы");
+    return [
+      {
+        field: e.field,
+        ...e.width != null ? { width: e.width } : {},
+        ...e.visible !== void 0 ? { visible: e.visible } : {}
+      }
+    ];
+  });
+}
+function g(a, {
+  resetContext: e = !1,
+  resetPage: t = !1,
+  includeSelection: f = !0,
+  layout: s
+} = {}) {
+  const r = a.getPageSize();
+  if (typeof r != "number" || !Number.isSafeInteger(r) || r <= 0)
+    throw new TypeError("Некорректный размер страницы снимка таблицы");
+  const i = e || t ? !1 : a.getPage(), d = i === !1 ? 1 : i;
+  if (!Number.isSafeInteger(d) || d <= 0)
+    throw new TypeError("Некорректная страница снимка таблицы");
+  return {
+    page: d,
+    size: r,
+    filters: e ? [] : a.getHeaderFilters().map((o) => ({
+      field: o.field,
+      value: o.value
+    })),
+    sort: e ? [] : a.getSorters().map(({ field: o, dir: l }) => ({ column: o, dir: l })),
+    layout: e ? [] : n(s ?? a.getColumnLayout()),
+    selected: e || t || !f ? [] : (a.getSelectedData?.() ?? []).flatMap(
+      (o) => o.id == null ? [] : [o.id]
+    )
+  };
+}
+function u(a, e = []) {
+  const t = /* @__PURE__ */ new Map();
+  for (const i of a)
+    if (i.field !== void 0) {
+      if (typeof i.field != "string" || !i.field.trim() || t.has(i.field))
+        throw new TypeError("Некорректное или повторное поле колонки таблицы");
+      t.set(i.field, i);
+    }
+  const f = /* @__PURE__ */ new Set(), s = e.flatMap(({ field: i, width: d, visible: o }) => {
+    if (typeof i != "string" || !i.trim() || f.has(i))
+      throw new TypeError("Некорректное или повторное поле layout таблицы");
+    f.add(i);
+    const l = t.get(i);
+    return l ? [
+      {
+        ...l,
+        ...d !== void 0 ? { width: d } : {},
+        ...o !== void 0 ? { visible: o } : {}
+      }
+    ] : [];
+  });
+  s.push(
+    ...a.filter((i) => i.field !== void 0 && !f.has(i.field)).map((i) => ({ ...i }))
+  );
+  let r = 0;
+  return a.map(
+    (i) => i.field === void 0 ? { ...i } : s[r++]
+  );
+}
+function v(a, e, t = []) {
+  const f = new Set(a.map((r) => r.field)), s = /* @__PURE__ */ new Map();
+  for (const r of e) {
+    if (typeof r.field != "string" || !r.field.trim() || typeof r.visible != "boolean" || !f.has(r.field) || s.has(r.field))
+      throw new TypeError("Некорректный черновик видимости колонок");
+    s.set(r.field, r.visible);
+  }
+  return u(a, n(t)).map(
+    (r) => r.field !== void 0 && s.has(r.field) ? { ...r, visible: s.get(r.field) } : r
+  );
+}
+function h(a, e) {
+  let t;
+  return {
+    track(f, s, r) {
+      const i = { state: f, isSameContext: s, operation: r };
+      return t = i, () => {
+        t === i && (t = void 0);
+      };
+    },
+    cancelSuperseded() {
+      t && a() === t.state && t.isSameContext() && t.operation.isSupersededByRequest() && e();
+    }
+  };
+}
+async function w(a, e, t, f) {
+  async function s(i) {
+    const d = await p(
+      a,
+      i,
+      f.signal,
+      f.owner
+    );
+    if (d.status === "cancelled") return "cancelled";
+    if (!f.isCurrent() || d.status === "superseded")
+      return "superseded";
+    if (d.status === "failed") throw d.error;
+    return d.status;
+  }
+  if (!f.isCurrent()) return "superseded";
+  f.beforeRequest();
+  const r = await s(
+    () => a.replaceData(t, { ...e.params, per_page: e.size })
+  );
+  if (r !== "applied") return r;
+  if (e.page !== a.getPage()) {
+    f.beforeRequest();
+    const i = await s(() => a.setPage(e.page));
+    if (i !== "applied") return i;
+  }
+  return f.isCurrent() ? "restored" : "superseded";
+}
+async function T(...a) {
+  const e = await w(...a);
+  return { status: e === "restored" ? "applied" : e };
+}
+export {
+  v as applyColumnVisibility,
+  g as captureTableSnapshot,
+  h as createSnapshotOwner,
+  u as mergeColumnLayout,
+  n as normalizeTableColumnLayout,
+  w as restoreTableData,
+  T as restoreTableOperationData,
+  b as toTableEditorColumns
+};

package/dist/modules/utils/tableAjaxRequest.js

@@ -0,0 +1,82 @@
+function j(t, n, u) {
+  return {
+    current_page: n,
+    data: [],
+    first_page_url: t,
+    from: 0,
+    last_page: 1,
+    last_page_url: t,
+    links: [],
+    next_page_url: null,
+    path: t,
+    per_page: u,
+    prev_page_url: null,
+    to: 0,
+    total: 0
+  };
+}
+function p(t = {}) {
+  const n = (r, o) => r == null || r === "" ? [] : Array.isArray(r) ? r.flatMap(
+    (a, i) => n(a, o ? `${o}[${i}]` : String(i))
+  ) : typeof r == "object" ? Object.entries(r).flatMap(
+    ([a, i]) => n(i, o ? `${o}[${a}]` : a)
+  ) : o ? [{ key: o, value: String(r) }] : [], u = (r) => r == null || r === "" ? !0 : Array.isArray(r) ? r.length === 0 : typeof r == "object" ? Object.keys(r).length === 0 : !1;
+  return async (r, o, a) => {
+    const i = (o.method || "GET").toUpperCase();
+    let f = r;
+    if (i === "GET" && a && typeof a == "object") {
+      const e = new URL(r, typeof window < "u" ? window.location.origin : "http://localhost");
+      Object.entries(a).forEach(([c, d]) => {
+        if (u(d)) return;
+        n(d, c).forEach(({ key: l, value: h }) => {
+          e.searchParams.set(l, h);
+        });
+      }), f = e.toString();
+    }
+    let s;
+    try {
+      s = await fetch(f, o);
+    } catch (e) {
+      throw t.onError?.(e), e;
+    }
+    if (s.status === 401)
+      throw t.onUnauthorized?.(s), s;
+    if (s.status === 404 && t.onNotFound)
+      return t.onNotFound({ url: f, params: a, response: s });
+    if (!s.ok) {
+      const e = await w(s);
+      throw t.onError?.(e), e;
+    }
+    try {
+      return await s.json();
+    } catch (e) {
+      const c = Object.assign(
+        e instanceof Error ? e : new Error("Malformed JSON"),
+        { kind: "malformed", status: 502, statusCode: 502 }
+      );
+      throw t.onError?.(c), c;
+    }
+  };
+}
+async function w(t) {
+  const n = await g(t);
+  return Object.assign(new Error(`HTTP ${t.status}`), {
+    status: t.status,
+    statusCode: t.status,
+    data: n,
+    headers: t.headers,
+    response: t
+  });
+}
+async function g(t) {
+  const n = t.clone();
+  try {
+    return await n.json();
+  } catch {
+    return await t.clone().text();
+  }
+}
+export {
+  j as createEmptyRemotePageResponse,
+  p as createTableAjaxRequestFunc
+};

package/dist/modules/utils/tableCancellation.js

@@ -0,0 +1,271 @@
+import { getTabulatorRuntime as q, createTabulatorRuntime as A } from "./tabulatorRuntime.js";
+import { withTableQueryParameters as g } from "./tableData.js";
+import { installTabulatorQueryAdapter as k } from "./tabulatorQueryAdapter.js";
+import { createTableLoadBoundary as M, withTableLoadBoundary as x, getTableRequestOperation as L, registerTableLoadTracker as j } from "./tableLoad.js";
+function G(n, p, f) {
+  let o = 0;
+  const c = /* @__PURE__ */ new WeakMap(), u = /* @__PURE__ */ new WeakMap();
+  return {
+    request: async function(...y) {
+      const d = ++o, l = {};
+      try {
+        const b = await n.apply(this, y);
+        u.set(l, { request: d, value: b, failed: !1 });
+      } catch (b) {
+        u.set(l, { request: d, value: b, failed: !0 });
+      }
+      return l;
+    },
+    wrapResponse: (y) => function(d, l, b) {
+      const w = b && typeof b == "object" ? u.get(b) : void 0;
+      if (!w)
+        throw new TypeError("r3ui-lib: ответ не принадлежит запросу таблицы");
+      if (!p() || w.request !== o) return !1;
+      if (w.failed) throw w.value;
+      let v;
+      try {
+        v = y.call(this, d, l, w.value);
+      } catch (R) {
+        if (!p() || w.request !== o) return !1;
+        throw R;
+      }
+      return !p() || w.request !== o ? !1 : (v === !1 && f(), v && typeof v == "object" && c.set(v, w.request), v);
+    },
+    isCurrentResponse(y) {
+      const d = y && typeof y == "object" ? c.get(y) : void 0;
+      return p() && (d === void 0 || d === o);
+    },
+    trackMappedResponse(y, d) {
+      const l = c.get(y);
+      l !== void 0 && c.set(d, l);
+    }
+  };
+}
+function N(n, p) {
+  if (n && typeof n == "object") {
+    const c = q(n);
+    if (c) {
+      if (!c.isActive())
+        throw new DOMException("Runtime Tabulator завершён", "AbortError");
+      return;
+    }
+  }
+  const f = A(n, !!p), o = f.loader;
+  try {
+    if (p) {
+      const u = o.mapParams;
+      f.patch(
+        o,
+        "mapParams",
+        function(...h) {
+          const i = u.apply(this, h);
+          return p.trackMappedResponse(h[0], i), i;
+        }
+      );
+    }
+    const c = o.chain;
+    if (f.patch(o, "chain", function(...u) {
+      const [h, i] = u;
+      return h === "data-loaded" && Array.isArray(i) && (i[0] === !1 || p && !p.isCurrentResponse(i[0])) ? !1 : c.apply(this, u);
+    }), p && D(f, p), typeof o.load == "function") {
+      const u = o.load;
+      f.patch(o, "load", function(...h) {
+        if (!f.isActive())
+          throw new DOMException("Runtime Tabulator завершён", "AbortError");
+        const i = f.retain();
+        try {
+          return Promise.resolve(u.apply(this, h)).finally(i);
+        } catch (y) {
+          throw i(), y;
+        }
+      });
+    }
+  } catch (c) {
+    throw f.rollback(), c;
+  }
+}
+function D(n, p) {
+  const { table: f, loader: o } = n, c = /* @__PURE__ */ new WeakMap();
+  let u, h;
+  const i = (r) => n.isActive() && r.order === o.requestOrder && !o.table.destroyed && p.isCurrentResponse(void 0), y = n.rowManager;
+  k(n);
+  const d = /* @__PURE__ */ new Set();
+  n.own(() => {
+    for (const r of d) r.boundary.finish({ status: "cancelled" });
+    d.clear();
+  });
+  let l;
+  const b = o.dispatchExternal;
+  n.patch(
+    o,
+    "dispatchExternal",
+    function(r, e) {
+      const t = r === "dataLoaded" ? l : void 0;
+      try {
+        return b.call(this, r, e);
+      } catch (a) {
+        if (t) {
+          t.outcome = { status: "failed", error: a };
+          return;
+        }
+        throw a;
+      }
+    }
+  );
+  const w = y.setData;
+  n.patch(
+    y,
+    "setData",
+    function(r, ...e) {
+      const t = l;
+      if (!t || t.rows !== r)
+        return w.call(this, r, ...e);
+      if (l = void 0, t.outcome.status === "failed") return Promise.resolve();
+      if (!i(t))
+        return t.outcome = { status: "superseded" }, Promise.resolve();
+      try {
+        t.applying = Promise.resolve(
+          w.call(this, r, ...e)
+        ).then(
+          () => {
+            t.outcome = { status: "applied" };
+          },
+          (a) => {
+            t.outcome = { status: "failed", error: a };
+          }
+        );
+      } catch (a) {
+        t.outcome = { status: "failed", error: a }, t.applying = Promise.resolve();
+      }
+      return t.applying;
+    }
+  );
+  const v = o.load;
+  n.patch(o, "load", function(...r) {
+    const e = {
+      order: this.requestOrder + 1,
+      outcome: { status: "cancelled" },
+      boundary: M()
+    };
+    d.add(e), h?.(e);
+    const t = u;
+    u = e;
+    let a;
+    try {
+      a = x(
+        f,
+        e.boundary,
+        () => g(
+          f,
+          r[1],
+          () => v.apply(this, r),
+          L(f)
+        )
+      );
+    } catch (s) {
+      throw e.outcome = i(e) ? { status: "failed", error: s } : { status: "superseded" }, d.delete(e), e.boundary.finish(e.outcome), s;
+    } finally {
+      u = t;
+    }
+    return a.then(
+      async (s) => {
+        try {
+          if (await e.applying, i(e) || (e.outcome = { status: "superseded" }), e.outcome.status === "failed" && !e.errorNotified) {
+            const { error: m } = e.outcome;
+            e.errorNotified = !0, console.error("Data Load Error: ", m), this.dispatchExternal("dataLoadError", m), !r[4] && i(e) && (this.alertError(), n.timeout(() => {
+              i(e) && this.clearAlert();
+            }, this.table.options.dataLoaderErrorTimeout));
+          }
+          return s;
+        } finally {
+          l === e && (l = void 0), i(e) || (e.outcome = { status: "superseded" }), d.delete(e), e.boundary.finish(e.outcome);
+        }
+      },
+      (s) => {
+        throw e.outcome = i(e) ? { status: "failed", error: s } : { status: "superseded" }, l === e && (l = void 0), d.delete(e), e.boundary.finish(e.outcome), s;
+      }
+    );
+  });
+  const R = o.mapParams;
+  n.patch(
+    o,
+    "mapParams",
+    function(r, e) {
+      const t = c.get(r);
+      if (!t) return R.call(this, r, e);
+      const a = t.value;
+      return !t.failed && a !== null && typeof a == "object" && !Array.isArray(a) && (t.value = R.call(this, a, e)), r;
+    }
+  );
+  const P = o.chain;
+  n.patch(o, "chain", function(...r) {
+    const [e, t] = r;
+    if (e === "data-load" && u) {
+      const a = u;
+      let s;
+      try {
+        s = P.apply(this, r);
+      } catch (m) {
+        s = Promise.reject(m);
+      }
+      return Promise.resolve(s).then(
+        (m) => {
+          const T = {};
+          return c.set(T, { state: a, value: m, failed: !1 }), T;
+        },
+        (m) => {
+          const T = {};
+          return c.set(T, { state: a, value: m, failed: !0 }), T;
+        }
+      );
+    }
+    if (e === "data-loaded" && Array.isArray(t) && t[0] && typeof t[0] == "object") {
+      const a = c.get(t[0]);
+      if (a) {
+        const { state: s, value: m, failed: T } = a;
+        if (!i(s))
+          return s.outcome = { status: "superseded" }, !1;
+        if (T)
+          return s.outcome = { status: "failed", error: m }, !1;
+        try {
+          const E = P.call(this, e, [m], r[2], m);
+          if (E === !1) s.outcome = { status: "cancelled" };
+          else if (Array.isArray(E))
+            s.rows = E, l = s;
+          else
+            return s.outcome = {
+              status: "failed",
+              error: new TypeError(
+                "Некорректный результат загрузки: ожидался массив строк"
+              )
+            }, !1;
+          return E;
+        } catch (E) {
+          return s.outcome = { status: "failed", error: E }, !1;
+        }
+      }
+    }
+    return P.apply(this, r);
+  }), n.own(
+    j(f, async (r) => {
+      let e;
+      const t = h;
+      h = (s) => {
+        e ??= s;
+      };
+      let a;
+      try {
+        a = r();
+      } finally {
+        h = t;
+      }
+      if (await a, !e)
+        throw new TypeError("r3ui-lib: операция не начала загрузку таблицы");
+      return e.outcome;
+    })
+  );
+}
+export {
+  G as createTableResponseGuard,
+  N as installTableCancellationGuard
+};

package/dist/modules/utils/tableColumnStorage.js

@@ -0,0 +1,55 @@
+import { mergeColumnLayout as f } from "./tableAdapter.js";
+function s(r, o) {
+  if (r != null) {
+    if (typeof r == "number" && Number.isFinite(r) && r >= 0)
+      return r;
+    if (typeof r == "string") {
+      const t = /^(\d+(?:\.\d+)?)(px|%)?$/.exec(r.trim());
+      if (t && Number.isFinite(Number(t[1])) && (o || t[2] !== "%"))
+        return t[2] === "px" ? Number(t[1]) : r.trim();
+    }
+    throw new TypeError("r3ui.table.columns_storage_invalid_width");
+  }
+}
+function l(r) {
+  if (!Array.isArray(r))
+    throw new TypeError("r3ui.table.columns_storage_invalid");
+  const o = /* @__PURE__ */ new Set();
+  return r.flatMap((t) => {
+    if (!t || typeof t != "object" || Array.isArray(t))
+      throw new TypeError("r3ui.table.columns_storage_invalid");
+    const i = t;
+    if (i.field === void 0) return [];
+    if (typeof i.field != "string" || !i.field.trim() || o.has(i.field))
+      throw new TypeError("r3ui.table.columns_storage_invalid_field");
+    if (o.add(i.field), i.visible !== void 0 && typeof i.visible != "boolean")
+      throw new TypeError("r3ui.table.columns_storage_invalid_visibility");
+    const d = s(i.width, !0), e = s(i.minWidth, !1);
+    return [
+      {
+        field: i.field,
+        ...d !== void 0 ? { width: d } : {},
+        ...e !== void 0 ? { minWidth: e } : {},
+        ...i.visible !== void 0 ? { visible: i.visible } : {}
+      }
+    ];
+  });
+}
+function m(r, o) {
+  const t = l(o), i = new Map(t.map((e) => [e.field, e])), d = r.map((e) => {
+    const n = e.field === void 0 ? void 0 : i.get(e.field);
+    return {
+      ...e,
+      ...n?.width !== void 0 ? { width: n.width } : {},
+      ...n?.minWidth !== void 0 ? { minWidth: n.minWidth } : {}
+    };
+  });
+  return f(
+    d,
+    t.map(({ field: e, visible: n }) => ({ field: e, visible: n }))
+  );
+}
+export {
+  l as normalizeStoredColumnLayout,
+  m as restoreStoredTableColumns
+};

package/dist/modules/utils/tableData.js

@@ -0,0 +1,118 @@
+import { toRaw as o } from "vue";
+import { cloneTableValue as p } from "./tableSnapshotValue.js";
+function T(e, r, t, a) {
+  const i = e?.options.dataSendParams ?? {}, g = Number(t[i.page ?? "page"] ?? e?.getPage() ?? 1), l = Number(
+    t[i.per_page ?? "per_page"] ?? t[i.size ?? "size"] ?? e?.getPageSize() ?? 10
+  );
+  if (!Number.isSafeInteger(g) || g < 1 || !Number.isSafeInteger(l) || l < 1)
+    throw new TypeError("Некорректные параметры страницы таблицы");
+  const m = new Set(
+    ["page", "size", "sort", "sorters", "filter", "per_page"].map(
+      (s) => i[s] ?? s
+    )
+  ), d = Object.fromEntries(
+    Object.entries(t).filter(([s]) => !m.has(s))
+  ), u = (e ? n.get(o(e))?.parameters?.() : void 0) ?? a, b = /* @__PURE__ */ new Set([
+    "page",
+    "size",
+    "sort",
+    "sorters",
+    "filter",
+    "per_page"
+  ]), f = (s) => p(
+    Object.fromEntries(
+      Object.entries(s).filter(([c]) => !b.has(c))
+    )
+  );
+  return {
+    url: r,
+    ...u ? {
+      parameterSources: {
+        configured: f(u.configured),
+        dynamic: f(u.dynamic),
+        explicit: f(u.explicit)
+      }
+    } : {},
+    extraParams: p(d),
+    programmaticFilters: p(e?.getFilters?.() ?? []),
+    params: p(t),
+    page: g,
+    size: l,
+    sort: (e?.getSorters() ?? []).map(({ field: s, dir: c }) => ({
+      column: s,
+      dir: c
+    })),
+    filters: (e?.getHeaderFilters() ?? []).map(({ field: s, value: c }) => ({
+      field: s,
+      value: p(c)
+    }))
+  };
+}
+const n = /* @__PURE__ */ new WeakMap();
+function h(e, r) {
+  return n.set(o(e), r), () => {
+    n.get(o(e)) === r && n.delete(o(e));
+  };
+}
+function P(e) {
+  return n.has(o(e));
+}
+function S(e, r, t) {
+  n.get(o(e))?.attachProjection(r, t);
+}
+function j(e, r, t = () => !0) {
+  const a = n.get(o(e));
+  return a ? a.prepare(r, t) : r();
+}
+function x(e, r) {
+  const t = n.get(o(e));
+  t ? t.configureParameters(r) : Object.assign(e.options, { ajaxParams: r });
+}
+function Q(e, r, t, a = !0) {
+  const i = n.get(o(e));
+  if (!i)
+    throw new TypeError("Движок не поддерживает восстановление выборки");
+  i.restoreSelection(r, t, a);
+}
+function z(e, r, t) {
+  const a = n.get(o(e));
+  if (!a)
+    throw new TypeError(
+      "Движок не поддерживает восстановление параметров таблицы"
+    );
+  a.restore(r, t);
+}
+function A(e, r, t) {
+  n.get(o(e))?.accept(r, t);
+}
+function E(e, r, t, a) {
+  if (r != null && (typeof r != "object" || Array.isArray(r)))
+    throw new TypeError("Некорректные параметры запроса таблицы");
+  const i = n.get(o(e));
+  return i?.withParameters ? i.withParameters(
+    r,
+    t,
+    a
+  ) : t();
+}
+function O(e) {
+  return n.get(o(e))?.parameterSource?.();
+}
+function N(e, r, t, a) {
+  const i = n.get(o(e));
+  return r && t && i?.withReplay ? i.withReplay(t, r, a) : a();
+}
+export {
+  A as acceptTableDataQuery,
+  S as attachTableProjection,
+  T as captureTableDataQuery,
+  x as configureTableParameters,
+  O as getTableParameterSource,
+  P as hasTableQueryAdapter,
+  j as prepareTableProjection,
+  h as registerTableQueryAdapter,
+  z as restoreAppliedTableQuery,
+  Q as restoreAppliedTableSelection,
+  E as withTableQueryParameters,
+  N as withTableQueryReplay
+};