r3ui-lib 1.3.19 → 1.3.21

package/dist/modules/composables/table/createTableRebuildTransaction.js

@@ -0,0 +1,61 @@
+import { waitForTableOperation as p, tableOperationStopped as v } from "../../utils/tableOperation.js";
+function w(t) {
+  const i = new AbortController();
+  let e = "preparing", s, a, n, f;
+  const l = () => !i.signal.aborted && e !== "settled" && e !== "failed" && t.isCurrent() && (a?.isCurrent() ?? !0), o = { signal: i.signal, isCurrent: l };
+  function c(r) {
+    e === "settled" || e === "failed" || (f = r, e = "settled", n?.());
+  }
+  function u(r = "cancelled") {
+    e === "settled" || e === "failed" || (i.abort(r), c(v(o)));
+  }
+  function g(r) {
+    n?.(), a = r;
+    const d = () => u(r.signal.reason === "superseded" ? "superseded" : "cancelled");
+    r.signal.addEventListener("abort", d, { once: !0 }), n = () => r.signal.removeEventListener("abort", d), r.signal.aborted && d();
+  }
+  function b() {
+    n?.(), n = void 0, a = void 0;
+  }
+  return g(t.source), {
+    operation: o,
+    generation: t.generation,
+    revision: t.revision,
+    source: t.source,
+    get stage() {
+      return e;
+    },
+    get snapshot() {
+      return s;
+    },
+    get result() {
+      return f;
+    },
+    wait(r) {
+      return p(r, o);
+    },
+    transfer(r) {
+      return l() ? (s = r, b(), e = "awaiting-instance", !0) : !1;
+    },
+    restore(r) {
+      return i.signal.aborted || !r.isCurrent() || !t.isCurrent() || e === "settled" || e === "failed" ? !1 : (g(r), e = "restoring", l());
+    },
+    release() {
+      if (!(e === "settled" || e === "failed")) {
+        if (!s) {
+          u("superseded");
+          return;
+        }
+        b(), e = "awaiting-instance";
+      }
+    },
+    finish: c,
+    fail() {
+      e === "settled" || e === "failed" || (e = "failed", n?.());
+    },
+    cancel: u
+  };
+}
+export {
+  w as createTableRebuildTransaction
+};

package/dist/modules/composables/table/createTableSession.js

@@ -0,0 +1,38 @@
+import { toRaw as r } from "vue";
+import { assertR3uiTableInstance as u } from "../../types/tableInstance.js";
+import { createTabulatorAdapter as b } from "./createTabulatorAdapter.js";
+function g(i, d) {
+  let e, o, l = 0;
+  function a(t = "cancelled") {
+    const n = o;
+    e = void 0, o = void 0, n?.abort(t);
+  }
+  return {
+    get current() {
+      return e;
+    },
+    matches(t) {
+      return !!e && r(e.instance) === r(t);
+    },
+    attach(t) {
+      if (u(t), e && r(e.instance) === r(t)) return e;
+      a("superseded");
+      const n = new AbortController();
+      o = n;
+      const c = {
+        signal: n.signal,
+        isCurrent: () => e === s && !n.signal.aborted && i()
+      }, s = Object.freeze({
+        id: ++l,
+        instance: r(t),
+        ...c,
+        engine: b(r(t), c, d)
+      });
+      return e = s, s;
+    },
+    detach: a
+  };
+}
+export {
+  g as createTableSessionOwner
+};

package/dist/modules/composables/table/createTableState.js

@@ -0,0 +1,122 @@
+import { selectTableQueryContext as u, planTableQueryRebuild as d, transitionTableQuery as l } from "./tableQueryTransitions.js";
+import { shallowRef as v, readonly as p } from "vue";
+function y(n) {
+  const a = v({
+    status: "idle",
+    active: !0,
+    desired: {},
+    appliedContext: n,
+    requestedContext: n,
+    startedGeneration: -1
+  }), s = (e) => {
+    a.value.status !== "disposed" && (a.value = { ...a.value, ...e });
+  };
+  function o(e) {
+    const t = l(a.value, e);
+    return t.state !== a.value && s(t.state), t;
+  }
+  return {
+    transition: o,
+    rebuildPolicy() {
+      return d(a.value);
+    },
+    queryContext(e, t = !1) {
+      return u(a.value, e, t);
+    },
+    state: p(a),
+    get value() {
+      return a.value;
+    },
+    begin(e) {
+      const t = {};
+      return s({ status: e, owner: t, failure: void 0 }), t;
+    },
+    move(e, t) {
+      a.value.owner === e && s({ status: t });
+    },
+    finish(e, t) {
+      a.value.owner === e && s({ status: t ? "ready" : "idle", owner: void 0 });
+    },
+    fail(e, t, r, i = a.value.snapshot) {
+      a.value.owner === e && s({
+        status: "failed",
+        failure: { kind: t, cause: r },
+        snapshot: i,
+        owner: void 0,
+        startedGeneration: -1
+      });
+    },
+    cancelled(e, t, r) {
+      a.value.owner === e && (r && a.value.snapshot === t ? s({
+        status: "failed",
+        failure: r,
+        owner: void 0,
+        startedGeneration: -1
+      }) : s({
+        status: "idle",
+        failure: void 0,
+        owner: void 0,
+        snapshot: a.value.snapshot === t ? void 0 : a.value.snapshot
+      }));
+    },
+    applied(e, t, r) {
+      a.value.owner === e && s({
+        status: "ready",
+        owner: void 0,
+        failure: void 0,
+        appliedContext: r,
+        snapshot: a.value.snapshot === t ? void 0 : a.value.snapshot
+      });
+    },
+    stop(e, t = "idle") {
+      s({
+        status: t,
+        owner: void 0,
+        failure: void 0,
+        startedGeneration: -1,
+        snapshot: e ? a.value.snapshot : void 0
+      });
+    },
+    requestData(e) {
+      o({ type: "requested", data: e });
+    },
+    acceptData(e) {
+      o({ type: "accepted", data: e });
+    },
+    setSnapshot(e) {
+      s({ snapshot: e });
+    },
+    desire(e, t, r) {
+      o({ type: "desired", intent: e, url: t, context: r });
+    },
+    setIntent(e) {
+      o({ type: "intent", intent: e });
+    },
+    setRequestedContext(e) {
+      o({ type: "context-requested", context: e });
+    },
+    setAppliedContext(e) {
+      o({ type: "context-applied", context: e });
+    },
+    markStarted(e) {
+      s({ startedGeneration: e });
+    },
+    setActive(e) {
+      s({ active: e });
+    },
+    dispose() {
+      o({ type: "disposed" }), s({
+        status: "disposed",
+        active: !1,
+        owner: void 0,
+        failure: void 0,
+        snapshot: void 0,
+        desired: {},
+        startedGeneration: -1
+      });
+    }
+  };
+}
+export {
+  y as createTableState
+};

package/dist/modules/composables/table/createTabulatorAdapter.js

@@ -0,0 +1,90 @@
+import { attachTableProjection as p, withTableQueryReplay as f, restoreAppliedTableSelection as b, restoreAppliedTableQuery as m, acceptTableDataQuery as y, prepareTableProjection as T, getTableParameterSource as C, hasTableQueryAdapter as w } from "../../utils/tableData.js";
+import { captureTableSnapshot as d, restoreTableData as g } from "../../utils/tableAdapter.js";
+import { trackTableLoad as s } from "../../utils/tableLoad.js";
+function x(t, o, a) {
+  a && p(t, a, o.isCurrent);
+  function l(r) {
+    if (!o.isCurrent() || r?.isCurrent() === !1)
+      throw new DOMException("Сессия таблицы завершена", "AbortError");
+  }
+  return {
+    get canRestoreQuery() {
+      return w(t);
+    },
+    capture(r) {
+      return l(), d(t, r);
+    },
+    parameterSource(r) {
+      return l(), C(t) ?? r;
+    },
+    url(r) {
+      return l(), t.getAjaxUrl?.() ?? (typeof t.options.ajaxURL == "string" ? t.options.ajaxURL : r());
+    },
+    setUrl(r, e) {
+      l(e), t.options.ajaxURL = r;
+    },
+    setColumns(r, e) {
+      l(e), t.options.columns = r, T(
+        t,
+        () => t.setColumns(
+          r.map((u) => ({
+            ...u,
+            title: u.title ?? ""
+          }))
+        ),
+        () => o.isCurrent() && e.isCurrent()
+      );
+    },
+    acceptQuery(r, e) {
+      l(e), y(t, r, e.isCurrent);
+    },
+    restoreQuery(r, e) {
+      l(e), m(t, r, e.isCurrent);
+    },
+    restoreSelection(r, e, u = !0) {
+      l(e), b(
+        t,
+        r,
+        e.isCurrent,
+        u
+      );
+    },
+    restoreView(r, e) {
+      for (const u of r.filters)
+        l(e), t.setHeaderFilterValue(
+          u.field,
+          u.value
+        );
+      l(e), t.setSort(r.sort);
+    },
+    select(r, e) {
+      l(e), r?.length && t.selectRow?.(r);
+    },
+    restore(r, e, u) {
+      return l(u), f(
+        t,
+        r.query,
+        u.owner,
+        () => g(
+          t,
+          { ...r, params: r.query?.params },
+          e,
+          u
+        )
+      );
+    },
+    load(r, e, u) {
+      if (l(u), e !== void 0 && (typeof e != "number" || !Number.isSafeInteger(e) || e <= 0))
+        throw new TypeError("Некорректный размер страницы загрузки таблицы");
+      return s(
+        t,
+        () => t.replaceData(r, { per_page: e }),
+        u.signal,
+        u.owner
+      );
+    }
+  };
+}
+export {
+  x as createTabulatorAdapter
+};

package/dist/modules/composables/table/tableQueryTransitions.js

@@ -0,0 +1,82 @@
+function a(t, e) {
+  switch (e.type) {
+    case "desired":
+      return {
+        state: {
+          ...t,
+          desired: {
+            intent: e.intent,
+            url: e.url,
+            context: e.context
+          },
+          ...e.intent === "context" ? { currentData: void 0, requestedContext: e.context } : {}
+        }
+      };
+    case "intent":
+      return {
+        state: {
+          ...t,
+          desired: { ...t.desired, intent: e.intent }
+        }
+      };
+    case "requested":
+      return {
+        state: {
+          ...t,
+          requestedData: e.data,
+          currentData: e.data,
+          requestedContext: e.data.context
+        }
+      };
+    case "accepted":
+      return {
+        state: {
+          ...t,
+          appliedData: e.data,
+          currentData: e.data,
+          requestedContext: e.data.context,
+          appliedContext: e.data.context
+        }
+      };
+    case "settled":
+      return {
+        state: {
+          ...t,
+          currentData: t.appliedData,
+          requestedContext: t.appliedData ? t.appliedData.context : t.appliedContext
+        },
+        restore: t.appliedData
+      };
+    case "context-requested":
+      return { state: { ...t, requestedContext: e.context } };
+    case "context-applied":
+      return { state: { ...t, appliedContext: e.context } };
+    case "preserve":
+      return { state: t, selection: t.currentData };
+    case "disposed":
+      return { state: { ...t, desired: {}, currentData: void 0 } };
+    default: {
+      const r = e;
+      throw new TypeError(
+        `Неизвестный переход таблицы: ${String(r)}`
+      );
+    }
+  }
+}
+function n(t, e, r = !1) {
+  return r && e ? e.context : t.currentData ? t.currentData.context : e ? e.context : t.requestedContext;
+}
+function c(t) {
+  const e = t.desired.intent ?? "preserve";
+  return {
+    mode: e,
+    resetContext: e === "context",
+    resetPage: e !== "preserve",
+    programmatic: e === "context" ? "initial" : "current"
+  };
+}
+export {
+  c as planTableQueryRebuild,
+  n as selectTableQueryContext,
+  a as transitionTableQuery
+};

package/dist/modules/composables/table/useManagedRemoteTable.js

@@ -0,0 +1,179 @@
+import { getTableRequestOperation as A, getTableLoadBoundary as D } from "../../utils/tableLoad.js";
+import { waitForTableOperation as T } from "../../utils/tableOperation.js";
+import { onUnmounted as O, onDeactivated as q, onActivated as S, shallowRef as k, computed as m, ref as E, provide as y, watch as g, unref as b } from "vue";
+import { useRemoteTable as j } from "./useRemoteTable.js";
+import { createTableLifecycle as U } from "./createTableLifecycle.js";
+import { applyFiltersKey as K, r3uiTableDefaultApiKey as L } from "../../types/tableInjectKeys.js";
+function P(r, a, d = {
+  createRemote: j,
+  onActivated: S,
+  onDeactivated: q,
+  onUnmounted: O
+}) {
+  let i;
+  const h = k(), C = m(
+    () => h.value?.appliedData.value?.total ?? 0
+  ), t = d.createRemote({
+    ...r,
+    total: C,
+    applyFiltersOnReady: !1,
+    watchQuickFilter: void 0,
+    getAjaxUrl: (n) => i?.acceptedUrl ?? r.getAjaxUrl(n),
+    createAjaxResponse: (n) => {
+      const u = E(n.value), p = r.createAjaxResponse(u);
+      return function(f, v, o) {
+        if (!i) throw new Error("Контроллер таблицы ещё не создан");
+        if (!i.isResponseCurrent(o)) return !1;
+        try {
+          u.value = n.value;
+          const l = Object.create(this ?? null), s = p.call(l, f, v, o), c = s === !1 ? void 0 : {
+            rows: s.data.slice(),
+            total: Number(s.last_row ?? u.value),
+            lastPage: Number(s.last_page)
+          };
+          if (c && (!Number.isSafeInteger(c.total) || c.total < 0 || !Number.isSafeInteger(c.lastPage) || c.lastPage < 1))
+            throw new TypeError("Некорректные счётчики ответа таблицы");
+          return i.responseTransformed(o, s === !1, c), s;
+        } catch (l) {
+          if (!i.isResponseCurrent(o)) return !1;
+          throw i.responseFailed(o, l), (a.presentUntrackedTransformErrors || i.isTrackedResponse(o)) && a.presentError(l), l;
+        }
+      };
+    }
+  }), w = () => r.getAjaxUrl(() => t.tableDefault.getFilterData()), R = {
+    remote: t,
+    getColumns: r.getColumns,
+    getAjaxUrl: w,
+    createRequest: (n) => async (u, p, f, v) => {
+      const o = i, l = o.beginRequest(
+        n,
+        v ?? A(t.table.value),
+        p.signal,
+        D(t.table.value),
+        { url: String(u), params: f }
+      );
+      if (!l) return o.superseded;
+      try {
+        const s = await T(
+          () => a.request(
+            u,
+            { ...p, signal: l.signal },
+            f,
+            l.isCurrent,
+            l
+          ),
+          l
+        );
+        return s.status === "applied" ? o.acceptResponse(s.value, l) : (o.requestStopped(l), o.superseded);
+      } catch (s) {
+        if (!l.isCurrent()) return o.superseded;
+        throw o.requestFailed(l, s), s;
+      }
+    },
+    presentError: a.presentError,
+    resetErrors: a.resetErrors,
+    refreshLabels: a.refreshLabels,
+    initialContext: a.initialContext,
+    captureContext: a.captureContext ? () => a.captureContext(t) : void 0,
+    onContextApplied: a.onContextApplied,
+    onDataApplied: a.onDataApplied,
+    initialLoad: a.initialLoad,
+    includeSelection: a.includeSelection,
+    applyOnReady: r.applyFiltersOnReady,
+    initializationFailure: a.initializationFailure,
+    columns: {
+      commit: t.handleColumnsChanged,
+      changed: t.handleColumnsApply,
+      titledOnly: a.columnsTitledOnly
+    }
+  }, e = U(R);
+  i = e, h.value = e, t.tableOptions.value.ajaxRequestFunc = R.createRequest(
+    e.generation
+  ), t.tableDefault.applyFilters = (n) => e.apply(n), y("applyFilters", t.tableDefault.applyFilters), y(K, t.tableDefault.applyFilters), y(L, t.tableDefault), g(
+    () => b(r.locale),
+    () => (a.beforeContextChange?.(), e.localeChanged()),
+    { flush: "sync" }
+  ), g(
+    t.isInitDone,
+    (n) => {
+      if (n) return e.startReady();
+    },
+    { flush: "sync" }
+  ), g(t.tableKey, () => e.tableKeyChanged(), { flush: "sync" }), r.watchQuickFilter && g(
+    r.watchQuickFilter,
+    (n, u) => {
+      if (n !== u)
+        return a.beforeContextChange?.(), e.quickFilterChanged();
+    },
+    { flush: "sync" }
+  ), d.onDeactivated(() => {
+    a.beforeContextChange?.(), e.deactivate();
+  }), d.onActivated(() => {
+    e.activate().catch(a.presentError);
+  }), d.onUnmounted(() => {
+    a.beforeContextChange?.(), e.dispose();
+  });
+  const x = {
+    get errorContext() {
+      return `${e.generation}:${e.revision}`;
+    },
+    requestedData: e.requestedData,
+    appliedData: e.appliedData,
+    status: e.status,
+    error: e.error,
+    canRetry: e.canRetry,
+    active: e.active,
+    disposed: e.disposed,
+    phase: e.phase,
+    preparing: e.preparing,
+    rebuilding: e.rebuilding,
+    restoring: m(() => !!e.pending.value),
+    canApplyColumns: e.canApplyColumns,
+    columnsApplying: e.columnsApplying
+  }, F = m(() => ({
+    key: t.tableKey.value,
+    props: {
+      ...t.tableLocalizations.value,
+      options: t.tableOptions.value,
+      columnHide: t.columnHide.value,
+      columnShow: t.columnShow.value
+    },
+    busy: e.active.value && (!t.isInitDone.value || !["idle", "ready", "failed", "disposed"].includes(
+      e.status.value
+    )),
+    status: e.status.value,
+    error: e.error.value,
+    canRetry: e.canRetry.value,
+    labels: {
+      loading: r.t("table_pagination.loading"),
+      error: r.t("pages.errors.unexpected"),
+      retry: r.t("pages.retry")
+    },
+    ready: e.tableReady,
+    retry: e.retry,
+    rowMoved: t.onTableRowMoved,
+    showColumn: t.onShowColumn,
+    hideColumn: t.onHideColumn
+  }));
+  return {
+    ...t,
+    total: C,
+    state: x,
+    tableView: F,
+    retry: e.retry,
+    handleTableReady: e.tableReady,
+    applyColumns: e.applyColumns,
+    applyFilters: (n = t.table.value, u) => e.executeFilters(n, u),
+    columnApplyContext: m(
+      () => JSON.stringify([
+        b(r.localStorageKey),
+        b(r.locale),
+        t.tableKey.value,
+        b(r.watchQuickFilter)
+      ])
+    )
+  };
+}
+export {
+  P as useManagedRemoteTable
+};

package/dist/modules/composables/table/useR3uiTableDefaultInject.js

@@ -0,0 +1,27 @@
+import { inject as e, provide as F } from "vue";
+import { r3uiTableDefaultApiKey as c, filterModalVisibilityKey as f, selectedFilterTitlesKey as y, setFilterParamsStringsKey as b, applyFiltersKey as p, resetFiltersKey as K, tableFiltersRefKey as d, tableRefKey as m } from "../../types/tableInjectKeys.js";
+function D() {
+  const t = e(c, null);
+  if (t)
+    return t;
+  const l = e(f, null) ?? e("filterModalVisibility"), i = e(y, null) ?? e("selectedFilterTitles"), s = e(b, null) ?? e(
+    "setFilterParamsStrings"
+  ), r = e(p, null) ?? e("applyFilters"), n = e(K, null) ?? e("resetFilters"), a = e(d, null) ?? e("tableFilters"), o = e(m, null) ?? e("table");
+  if (!l || !i || !s || !r || !n || !a || !o)
+    throw new Error(
+      "useR3uiTableDefaultInject: контекст useTableDefault не найден"
+    );
+  const u = {
+    filterModalVisibility: l,
+    selectedFilterTitles: i,
+    setFilterParamsStrings: s,
+    applyFilters: r,
+    resetFilters: n,
+    tableFilters: a,
+    table: o
+  };
+  return F(c, u), u;
+}
+export {
+  D as useR3uiTableDefaultInject
+};

package/dist/modules/composables/table/useRemoteTable.js

@@ -0,0 +1,96 @@
+import { ref as o, computed as d, provide as j, watch as A, onMounted as E } from "vue";
+import { assertR3uiTableInstance as K } from "../../types/tableInstance.js";
+import S from "./useTableDefault.js";
+import { useTabulatorTableProps as D } from "../../utils/createTabulatorTableProps.js";
+import { createTableAjaxRequestFunc as M, createEmptyRemotePageResponse as O } from "../../utils/tableAjaxRequest.js";
+import { toTableEditorColumns as U, applyColumnVisibility as z } from "../../utils/tableAdapter.js";
+function L(e) {
+  const f = D(e.t, e.locale), i = e.total ?? o(0), u = o(!1), s = e.createAjaxResponse(i), n = o({
+    ...e.defaultTableOptions ?? {},
+    columns: e.getColumns(),
+    ajaxResponse: s,
+    ajaxRequestFunc: M({
+      onUnauthorized: e.onUnauthorized,
+      onError: e.onError,
+      onNotFound: e.notFound === "empty" ? ({
+        url: a,
+        params: t
+      }) => O(
+        a,
+        Number(t.page || 1),
+        Number(t.per_page || 10)
+      ) : void 0
+    })
+  }), c = d({
+    get: () => n.value.columns,
+    set: (a) => {
+      n.value.columns = a;
+    }
+  }), y = d(
+    () => U(c.value)
+  ), b = typeof e.localStorageKey == "string" ? o(e.localStorageKey) : e.localStorageKey, r = S({
+    localStorageKey: b,
+    getAjaxResponse: async () => s,
+    getAjaxUrl: () => e.getAjaxUrl(() => r.getFilterData()),
+    tableOptions: n,
+    initialFilters: e.initialFilters,
+    getColumns: e.getColumns,
+    initialFilterTitles: e.initialFilterTitles
+  }), {
+    tableKey: v,
+    columnHide: x,
+    columnShow: F,
+    table: l,
+    onTableRowMoved: g,
+    onShowColumn: C,
+    onHideColumn: p,
+    handleColumnsChanged: m,
+    handleColumnsApply: R
+  } = r;
+  function T(a) {
+    m(
+      z(
+        n.value.columns,
+        a.map(({ field: t, visible: w }) => ({ field: t, visible: w }))
+      )
+    );
+  }
+  async function h(a) {
+    a !== null && K(a), l.value = a, u.value && e.applyFiltersOnReady !== !1 && l.value && await r.applyFilters(l.value);
+  }
+  if (e.filtersContextKey) {
+    const a = { total: i, tableDefault: r }, t = e.extendFiltersContext ? { ...a, ...e.extendFiltersContext(a) } : a;
+    j(e.filtersContextKey, t);
+  }
+  return e.watchQuickFilter && A(
+    () => e.watchQuickFilter.value,
+    async (a, t) => {
+      a !== t && l.value && u.value && await r.applyFilters(l.value);
+    },
+    { deep: !0 }
+  ), E(async () => {
+    e.onMountedExtra && await e.onMountedExtra(), u.value = !0, l.value && e.applyFiltersOnReady !== !1 && await r.applyFilters(l.value);
+  }), {
+    tableOptions: n,
+    tableColumns: c,
+    editorColumns: y,
+    applyEditorColumns: T,
+    tableKey: v,
+    columnHide: x,
+    columnShow: F,
+    tableLocalizations: f,
+    handleTableReady: h,
+    onTableRowMoved: g,
+    onShowColumn: C,
+    onHideColumn: p,
+    handleColumnsChanged: m,
+    handleColumnsApply: R,
+    total: i,
+    tableDefault: r,
+    table: l,
+    isInitDone: u
+  };
+}
+export {
+  L as useRemoteTable
+};