r3ui-lib 1.3.20 → 1.3.21

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

@@ -0,0 +1,719 @@
+import { createTableProjection as ot } from "../../utils/tableProjection.js";
+import { cloneTableValue as Ie } from "../../utils/tableSnapshotValue.js";
+import { createTableParameterSource as ct } from "../../utils/tableQueryParameters.js";
+import { captureTableDataQuery as Qe } from "../../utils/tableData.js";
+import { createTableState as dt } from "./createTableState.js";
+import { createTableRebuildTransaction as ft } from "./createTableRebuildTransaction.js";
+import { createTableSessionOwner as vt } from "./createTableSession.js";
+import { createTableCommandScheduler as pt } from "./createTableCommandScheduler.js";
+import { computed as D, readonly as re, nextTick as Ve, watch as gt, toRaw as O } from "vue";
+import { assertR3uiTableInstance as mt } from "../../types/tableInstance.js";
+import { createSnapshotOwner as bt, mergeColumnLayout as We, applyColumnVisibility as yt, normalizeTableColumnLayout as Ct } from "../../utils/tableAdapter.js";
+import { waitForTableOperation as ae, tableOperationStopped as U, createTableOperation as ht } from "../../utils/tableOperation.js";
+function Me(s, a, {
+  deferUntilRequest: ne = !1,
+  owner: Q
+} = {}) {
+  let X = a(), n = 0, w = !ne;
+  const J = () => w && a() > X + n;
+  return {
+    signal: Q?.signal,
+    owner: Q,
+    isSupersededByRequest: J,
+    isCurrent: () => (Q?.isCurrent() ?? !0) && s() && !J(),
+    beforeRequest() {
+      X = a(), n = 1, w = !0;
+    }
+  };
+}
+async function wt(s, a) {
+  return (await ae(() => s, {
+    signal: a,
+    isCurrent: () => !a.aborted
+  })).status === "applied" ? "ready" : "superseded";
+}
+function Lt(s) {
+  const { remote: a } = s, ne = a.tableOptions.value.ajaxParams, Q = ot(ne), X = Ie(
+    a.tableOptions.value.initialFilter ?? []
+  ), n = dt(
+    s.initialContext
+  ), w = D(() => n.value.status), J = D(() => n.value.active), P = D(() => w.value === "disposed"), ie = D(
+    () => w.value === "disposed" ? "disposed" : w.value === "building" || w.value === "awaiting-instance" ? "building" : w.value === "restoring" ? "restoring" : "idle"
+  ), me = D(() => w.value === "preparing"), Se = D(() => w.value === "columns"), L = D(() => ie.value === "building"), v = D({
+    get: () => n.value.snapshot,
+    set: n.setSnapshot
+  }), K = D({
+    get: () => n.value.startedGeneration,
+    set: n.markStarted
+  }), V = D({
+    get: () => n.value.desired.intent,
+    set: n.setIntent
+  }), se = D({
+    get: () => n.value.requestedContext,
+    set: n.setRequestedContext
+  });
+  let c = 0, y = 0, _ = 0, Y = 0, be = !1, ye = new AbortController();
+  const W = pt(), z = vt(
+    () => g() && O(a.table.value) === z.current?.instance,
+    Q
+  );
+  a.table.value && z.attach(a.table.value);
+  let le, j, m, E, B, Z, q, H, T;
+  const Ce = Symbol("superseded table response"), $ = /* @__PURE__ */ new WeakMap(), he = /* @__PURE__ */ new WeakMap(), De = /* @__PURE__ */ new WeakMap(), Oe = /* @__PURE__ */ new WeakMap(), ue = /* @__PURE__ */ new WeakSet(), Ae = /* @__PURE__ */ new WeakSet(), oe = bt(
+    () => v.value,
+    () => {
+      v.value = void 0;
+    }
+  ), Ge = a.tableDefault.applyFiltersOperation ?? a.tableDefault.applyFilters;
+  function ce(e, t) {
+    e && e.command.finish(t);
+  }
+  const g = () => J.value && !P.value;
+  function de() {
+    ye.abort("superseded"), ye = new AbortController();
+  }
+  function k(e = !1, t = "cancelled") {
+    e ? j?.release() : j?.cancel(t), z.detach(t), W.invalidate(t), T?.abort(t), T?.dispose(), T = void 0, de(), H = void 0, q = void 0, n.stop(
+      e,
+      e && ie.value === "building" ? "awaiting-instance" : "idle"
+    );
+  }
+  function R(e) {
+    return z.matches(e) ? z.current : (z.current && k(!0, "superseded"), z.attach(e));
+  }
+  function ee() {
+    c++, j?.cancel("superseded"), W.invalidate(), T?.abort("superseded"), T?.dispose(), H = void 0, de();
+  }
+  function Je(e, t, r, l, u) {
+    if (!g() || e !== c || t && (t.generation !== c || t.revision !== y || !t.isCurrent()))
+      return;
+    const i = u ? Qe(a.table.value, u.url, u.params) : void 0;
+    i && Q.requested(i), T?.abort("superseded"), T?.dispose();
+    const f = ++_, o = t ? t.context : n.queryContext(
+      v.value,
+      L.value || ie.value === "restoring"
+    );
+    i || (se.value = o), oe.cancelSuperseded();
+    const p = t?.revision ?? y, d = a.table.value ? R(a.table.value) : z.current, A = t ? void 0 : W.schedule({
+      kind: "request",
+      generation: e,
+      revision: p,
+      context: o,
+      signal: r ?? void 0,
+      signals: d ? [d.signal] : [],
+      isCurrent: () => g() && e === c && p === y && f === _ && (d?.isCurrent() ?? !0)
+    });
+    A?.start(), T = ht({
+      kind: "request",
+      generation: e,
+      revision: p,
+      context: o,
+      parent: t ?? A?.operation,
+      signal: r,
+      signals: [d?.signal],
+      isCurrent: () => g() && e === c && p === y && f === _ && (d?.isCurrent() ?? !0)
+    });
+    const b = T.operation, S = n.value.failure;
+    return A && Oe.set(b, {
+      owner: n.begin("loading"),
+      command: A,
+      snapshot: v.value,
+      failure: S
+    }), i && (he.set(b, i), n.requestData({ query: i, context: o })), l && (ue.add(b), l.subscribe((h) => fe(b, h))), b;
+  }
+  function fe(e, t) {
+    if (Ae.has(e)) return;
+    Ae.add(e);
+    const r = Oe.get(e);
+    let l = t;
+    const u = (i) => {
+      const f = a.table.value;
+      if (!e.isCurrent()) return;
+      const o = he.get(e), p = f ? {
+        ...we(f, !1, !1),
+        ...o ? {
+          page: o.page,
+          size: o.size,
+          filters: o.filters.map((d) => ({ ...d })),
+          sort: o.sort.map((d) => ({ ...d }))
+        } : {},
+        url: o?.url ?? R(f).engine.url(s.getAjaxUrl),
+        context: e.context,
+        query: o
+      } : v.value;
+      !r && p && n.setSnapshot(p), r && n.fail(
+        r.owner,
+        f ? "restore" : "filters",
+        i,
+        p
+      );
+    };
+    try {
+      if (t.status === "applied" && e.isCurrent()) {
+        const i = he.get(e), f = De.get(e);
+        if (i && f) {
+          const o = { query: i, context: e.context, ...f };
+          if (n.acceptData(o), !e.isCurrent() || (a.table.value && R(a.table.value).engine.acceptQuery(o, e), !e.isCurrent())) return;
+          s.onDataApplied?.(o);
+        }
+        if (!e.isCurrent() || (e.context !== void 0 && s.onContextApplied?.(e.context), !e.isCurrent())) return;
+        r ? n.applied(r.owner, r.snapshot, e.context) : n.setAppliedContext(e.context);
+      } else if (t.status === "failed" && e.isCurrent()) {
+        if (u(t.error), !e.isCurrent()) return;
+        const { restore: i } = n.transition({
+          type: "settled",
+          outcome: "failed"
+        });
+        e.isCurrent() && i && a.table.value && R(a.table.value).engine.canRestoreQuery && R(a.table.value).engine.restoreSelection(
+          i,
+          e
+        );
+      } else {
+        if (t.status === "cancelled" && e.isCurrent()) {
+          const { restore: i } = n.transition({
+            type: "settled",
+            outcome: "cancelled"
+          });
+          e.isCurrent() && i && a.table.value && R(a.table.value).engine.canRestoreQuery && R(a.table.value).engine.restoreSelection(
+            i,
+            e
+          );
+        }
+        r && n.cancelled(r.owner, r.snapshot, r.failure);
+      }
+    } catch (i) {
+      throw l = { status: "failed", error: i }, u(i), i;
+    } finally {
+      r && (e.isCurrent() ? l.status === "failed" ? r.command.fail(l.error) : r.command.finish({ status: l.status }) : r.command.finish(U(e)));
+    }
+  }
+  function Ke(e) {
+    ue.has(e) || fe(e, { status: "cancelled" });
+  }
+  function Pe(e, t) {
+    ue.has(e) || fe(e, { status: "failed", error: t });
+  }
+  function _e(e, t) {
+    return t.isCurrent() ? (e && typeof e == "object" && $.set(e, t), e) : Ce;
+  }
+  function Be(e) {
+    return g() && e !== Ce && !(e && typeof e == "object" && $.get(e)?.isCurrent() === !1);
+  }
+  function Te(e, t = !1, r) {
+    const l = e && typeof e == "object" ? $.get(e) : void 0;
+    l && r && De.set(l, r), l && !ue.has(l) && fe(l, { status: t ? "cancelled" : "applied" });
+  }
+  function He(e) {
+    Te(e);
+  }
+  const Fe = () => s.createRequest(c);
+  function we(e, t, r, l = "columns") {
+    const u = R(e).engine.capture({
+      resetContext: t,
+      resetPage: r,
+      includeSelection: s.includeSelection !== !1
+    }), { selection: i } = n.transition({
+      type: "preserve",
+      reason: l
+    }), f = e.options.dataSendParams ?? {}, o = !t && !r && i ? Qe(
+      e,
+      R(e).engine.url(s.getAjaxUrl),
+      {
+        ...i.query.params,
+        [f.page ?? "page"]: u.page,
+        [f.size ?? "size"]: u.size,
+        per_page: u.size
+      },
+      i.query.parameterSources
+    ) : void 0;
+    if (o && Q.requested(o), s.includeSelection === !1) {
+      const { selected: p, ...d } = u;
+      return { ...d, ...o ? { query: o } : {} };
+    }
+    return { ...u, ...o ? { query: o } : {} };
+  }
+  function je(e) {
+    j?.cancel("superseded");
+    const t = c, r = y, l = ft({
+      source: e,
+      generation: t,
+      revision: r,
+      isCurrent: () => j === l && g() && t === c && r === y
+    });
+    return j = l, l;
+  }
+  async function I() {
+    if (!g()) return;
+    const e = a.table.value;
+    if (!e || !a.isInitDone.value) return;
+    const t = R(e), r = je(t), l = n.begin("building");
+    K.value = -1;
+    const u = n.rebuildPolicy(), i = u.mode === "context", f = u.mode === "apply", o = m ?? E ?? B;
+    let p = !1;
+    try {
+      if ((i || f) && ((await r.wait(() => Ve())).status !== "applied" || (await r.wait(
+        () => a.tableDefault.fetchData(r.operation)
+      )).status !== "applied") || !r.operation.isCurrent()) return;
+      i && n.desire(
+        "context",
+        s.getAjaxUrl(),
+        s.captureContext?.()
+      );
+      const d = v.value ?? {
+        ...we(
+          e,
+          u.resetContext,
+          u.resetPage,
+          "locale"
+        ),
+        url: f && o?.url ? o.url : i ? n.value.desired.url ?? s.getAjaxUrl() : t.engine.url(s.getAjaxUrl),
+        context: f && o ? o.context : i ? n.value.desired.context ?? s.captureContext?.() : se.value
+      }, A = i ? a.tableOptions.value.columns : s.getColumns();
+      Q.configure(a.tableOptions.value.ajaxParams);
+      const b = {
+        ...a.tableOptions.value,
+        columns: We(A, d.layout),
+        ajaxURL: d.url ?? s.getAjaxUrl(),
+        paginationInitialPage: d.page,
+        paginationSize: d.size,
+        ajaxParams: ct(
+          i ? Q.configurationSource() : t.engine.parameterSource(
+            a.tableOptions.value.ajaxParams
+          ),
+          d.size,
+          d.query?.parameterSources?.explicit ?? (d.query?.parameterSources ? {} : d.query?.extraParams) ?? {}
+        ),
+        initialFilter: Ie(
+          d.query?.programmaticFilters ?? (u.programmatic === "initial" ? X : e.getFilters?.() ?? X)
+        ),
+        initialHeaderFilter: d.filters,
+        initialSort: d.sort,
+        ajaxRequestFunc: Fe()
+      };
+      if (!r.transfer(d)) return;
+      p = !0, v.value = r.snapshot, Y = c, m = void 0, V.value = void 0, a.tableOptions.value = b, k(!0, "superseded"), a.table.value = null, be = !0;
+      try {
+        a.tableKey.value++;
+      } finally {
+        be = !1;
+      }
+    } catch (d) {
+      if (!r.operation.isCurrent()) return;
+      throw r.fail(), n.fail(l, "rebuild", d), s.presentError(d), d;
+    } finally {
+      if (!p && j === r && (n.finish(l, !1), g() && t.isCurrent() && (r.generation !== c || r.revision !== y)))
+        return I();
+    }
+  }
+  function Ne() {
+    if (!P.value && ((m || E || B) && (V.value ??= "apply"), ee(), s.resetErrors?.(), g() && !L.value && !me.value))
+      return I();
+  }
+  function Xe() {
+    P.value || be || (ee(), y++, v.value = void 0, m = void 0, V.value = void 0, K.value = -1, k(!1, "superseded"), a.table.value = null, n.stop(!0, "awaiting-instance"), Y = c, a.tableOptions.value.ajaxRequestFunc = Fe());
+  }
+  function Ye() {
+    if (!P.value && (ee(), y++, v.value = void 0, m = void 0, n.desire("context", s.getAjaxUrl(), s.captureContext?.()), !L.value))
+      return I();
+  }
+  function xe() {
+    return Z || (Z = (async () => {
+      for (; m && g() && !L.value && a.isInitDone.value; ) {
+        const e = m;
+        m = void 0;
+        const t = () => g() && e.generation === c && e.revision === y && O(e.instance) === O(a.table.value) && (e.external?.isCurrent() ?? !0) && !e.external?.signal.aborted;
+        if (!t()) {
+          ce(e, { status: "superseded" });
+          continue;
+        }
+        B = e;
+        const r = e.command.operation, l = n.begin("loading");
+        let u = !1;
+        try {
+          if (e.session = R(e.instance), !e.command.start()) continue;
+          if (await wt(
+            le,
+            r.signal
+          ) === "superseded" || !t()) {
+            ce(e, U(r));
+            continue;
+          }
+          E = e;
+          const f = await ae(
+            () => Ge(e.instance, {
+              signal: r.signal,
+              isCurrent: r.isCurrent,
+              owner: r,
+              closeDialog: e.closeDialog
+            }),
+            r
+          ), o = f.status === "applied" ? f.value : f;
+          (!o || o.status === "applied") && r.isCurrent() && (se.value = e.context, u = !0, n.setAppliedContext(e.context)), ce(
+            e,
+            o ?? (r.isCurrent() ? { status: "applied" } : U(r))
+          );
+        } catch (i) {
+          t() && (e.command.fail(i), n.fail(l, "filters", i), s.presentError(i)), ce(e, U(r));
+        } finally {
+          n.finish(l, u && r.isCurrent()), B === e && (B = void 0), E === e && (E = void 0);
+        }
+      }
+    })().finally(() => {
+      if (Z = void 0, m && g() && !L.value && a.isInitDone.value)
+        return xe();
+    }), Z);
+  }
+  function Ue(e, t) {
+    const r = qe(e, t);
+    return r && J.value && e && a.table.value && !L.value && a.isInitDone.value ? r.command.result.then(() => {
+    }) : Promise.resolve();
+  }
+  function Ze(e, t) {
+    return P.value ? Promise.resolve({ status: "cancelled" }) : t && (!t.isCurrent() || t.signal.aborted) ? Promise.resolve(U(t)) : qe(e, void 0, t).command.result;
+  }
+  function Le(e) {
+    const t = { ...e }, r = e.instance && a.table.value && O(e.instance) === O(a.table.value) ? R(a.table.value) : void 0;
+    t.session = r;
+    const l = W.schedule({
+      kind: "filters",
+      generation: e.generation,
+      revision: e.revision,
+      context: e.context,
+      external: e.external,
+      signals: r ? [r.signal] : [],
+      isCurrent: () => g() && e.generation === c && e.revision === y && (t.session?.isCurrent() ?? !0)
+    });
+    return t.command = l, t;
+  }
+  function qe(e, t, r, l) {
+    if (P.value) return;
+    const u = t ?? s.getAjaxUrl(), i = l ? l.value : s.captureContext?.();
+    n.desire("apply", u, i);
+    const f = ++y;
+    j?.cancel("superseded"), de(), T?.abort("superseded"), H = void 0, v.value = void 0, m = Le({
+      external: r,
+      instance: e,
+      generation: c,
+      revision: f,
+      url: u,
+      context: i,
+      closeDialog: a.tableDefault.captureFilterDialogClose?.()
+    });
+    const o = m;
+    return !J.value || !e || !a.table.value || L.value || !a.isInitDone.value ? (V.value ??= "apply", o) : (V.value = void 0, xe(), o);
+  }
+  async function $e(e) {
+    if (!s.refreshLabels) return;
+    const t = s.refreshLabels(e.isCurrent);
+    le = t;
+    try {
+      await ae(() => t, e);
+    } finally {
+      le === t && (le = void 0);
+    }
+  }
+  async function ve() {
+    if (!g()) return;
+    const e = s.initializationFailure?.();
+    if (e) {
+      s.presentError(e.error);
+      return;
+    }
+    const t = a.table.value;
+    if (!(!t || !a.isInitDone.value || L.value)) {
+      if ((s.initialLoad !== "replace" || v.value || K.value !== -1) && Y !== c)
+        return I();
+      if (s.initialLoad === "replace") return Re(t);
+      if (!(v.value || K.value === c)) {
+        if (K.value = c, m) {
+          if (m.command.phase === "settled" && m.generation === c) {
+            m = void 0, V.value = void 0;
+            return;
+          }
+          return m.command.phase === "settled" ? m = Le({
+            ...m,
+            instance: t,
+            generation: c,
+            external: void 0
+          }) : m.instance = t, V.value = void 0, xe();
+        }
+        if (s.applyOnReady !== !1) return Ue(t);
+      }
+    }
+  }
+  function Re(e) {
+    if (q && q.generation === c && q.revision === y && O(q.instance) === O(e))
+      return q.promise;
+    if (!g() || K.value === c)
+      return Promise.resolve();
+    K.value = c;
+    const t = {
+      instance: e,
+      generation: c,
+      revision: y,
+      promise: Promise.resolve()
+    };
+    return q = t, t.promise = ke(e, t).finally(() => {
+      q === t && (q = void 0);
+    }), t.promise;
+  }
+  async function ke(e, t) {
+    const r = R(e), l = r.engine, u = v.value, i = n.value.failure?.kind === "columns", f = c, o = y;
+    let p = j;
+    if ((!p || p.generation !== f || p.revision !== o || !p.operation.isCurrent() || p.snapshot !== u) && (p = je(r), u && p.transfer(u)), !p.restore(r)) return;
+    const d = p;
+    let A;
+    const b = () => q === t && g() && f === c && o === y && r.isCurrent() && d.operation.isCurrent(), S = W.schedule({
+      kind: "restore",
+      generation: f,
+      revision: o,
+      context: u?.context ?? se.value,
+      signal: ye.signal,
+      signals: [r.signal, d.operation.signal],
+      isCurrent: b
+    });
+    S.start();
+    const h = Me(
+      b,
+      () => _,
+      {
+        deferUntilRequest: s.initialLoad === "replace",
+        owner: S.operation
+      }
+    ), pe = u ? oe.track(u, b, h) : void 0, { isCurrent: M } = h, F = n.begin(u ? "restoring" : "preparing");
+    try {
+      if (u) {
+        if ((s.initialLoad !== "replace" || s.refreshLabels) && (await ae(
+          () => $e(S.operation),
+          S.operation
+        )).status !== "applied" || !M()) return;
+        const C = u.url ?? s.getAjaxUrl();
+        l.setUrl(C, h);
+        const G = n.value.appliedData;
+        if (u.query && G && l.canRestoreQuery ? l.restoreQuery({ ...G, query: u.query }, h) : i && l.restoreView(u, h), await l.restore(u, C, h) !== "restored" || !M()) return;
+        l.select(u.selected, h), v.value === u && (v.value = void 0), A = { status: "applied" };
+      } else {
+        try {
+          if ((await ae(
+            () => a.tableDefault.fetchData(S.operation),
+            S.operation
+          )).status !== "applied")
+            return g() && f !== c && O(e) === O(a.table.value) ? I() : void 0;
+        } finally {
+          n.move(F, "loading");
+        }
+        if (!g() || O(e) !== O(a.table.value))
+          return;
+        if (l.setColumns(a.tableOptions.value.columns, h), Y !== c) return I();
+        const C = s.getAjaxUrl();
+        l.setUrl(C, h), h.beforeRequest();
+        const G = await l.load(
+          C,
+          a.tableOptions.value.paginationSize,
+          h
+        );
+        if (M() && G.status === "failed") throw G.error;
+        G.status !== "failed" && (A = G);
+      }
+    } catch (C) {
+      if (!M())
+        return !P.value && f !== c && O(e) === O(a.table.value) && s.initialLoad === "replace" ? I() : void 0;
+      throw S.fail(C), d.fail(), n.fail(F, "restore", C), s.presentError(C), C;
+    } finally {
+      S.finish(
+        h.isCurrent() ? { status: "applied" } : U(S.operation)
+      ), pe?.(), b() && v.value === u && !M() && (v.value = void 0), n.finish(F, A?.status === "applied"), q === t && j === d && d.finish(
+        A ?? U(S.operation)
+      );
+    }
+  }
+  async function et(e) {
+    if (P.value) return;
+    if (e === null) {
+      (z.current || T) && (k(), m = void 0), a.table.value = null;
+      return;
+    }
+    if (mt(e), q && q.generation === c && q.revision === y && O(q.instance) === O(e))
+      return q.promise;
+    const t = !z.matches(e);
+    if (R(e), a.table.value = e, t) {
+      K.value = -1;
+      const r = n.value.appliedData, l = R(e);
+      r && l.engine.canRestoreQuery && g() && l.engine.restoreSelection(
+        r,
+        {
+          isCurrent: () => g() && l.isCurrent()
+        },
+        !1
+      );
+    }
+    if (w.value === "awaiting-instance" && n.begin(v.value ? "restoring" : "loading"), !!g())
+      return s.initialLoad === "replace" ? ve() : Y !== c ? I() : v.value ? Re(e) : ve();
+  }
+  const ze = D(
+    () => g() && !!a.table.value && a.isInitDone.value && !L.value && !me.value && !v.value && !Se.value
+  );
+  async function tt(e, t, r) {
+    if (t?.signal.aborted || t?.isCurrent() === !1)
+      return U(t);
+    if (!ze.value)
+      throw new Error("Таблица ещё не готова к применению колонок");
+    if (!s.columns) throw new Error("Не настроено применение колонок");
+    const l = a.table.value, u = R(l), i = u.engine, f = c, o = we(l, !1, !1), p = We(
+      a.tableOptions.value.columns,
+      o.layout
+    ), d = new Set(
+      p.filter((x) => !s.columns?.titledOnly || x.title).map((x) => x.field)
+    ), A = yt(
+      p,
+      e.filter((x) => d.has(x.field))
+    ), b = {
+      ...o,
+      layout: Ct(
+        A.map(({ field: x, width: N, visible: ge }) => ({
+          field: x,
+          width: typeof N == "number" ? N : void 0,
+          visible: ge
+        }))
+      ),
+      url: i.url(s.getAjaxUrl),
+      context: n.queryContext()
+    };
+    s.columns.commit(A);
+    const S = ++y;
+    j?.cancel("superseded"), de(), T?.abort("superseded"), m = void 0, V.value = void 0, _++, v.value = b;
+    const h = {};
+    H = h;
+    const pe = n.begin("columns"), M = () => H === h && g() && c === f && y === S && u.isCurrent() && !t?.signal.aborted && (t?.isCurrent() ?? !0), F = W.schedule({
+      kind: "columns",
+      generation: f,
+      revision: S,
+      context: b.context,
+      signal: t?.signal,
+      signals: [u.signal],
+      isCurrent: M
+    });
+    F.start();
+    const C = Me(
+      M,
+      () => _,
+      { deferUntilRequest: !0, owner: F.operation }
+    ), G = oe.track(b, M, C);
+    try {
+      if (r?.(), s.columns.changed(), await Ve(), !C.isCurrent())
+        return U(F.operation);
+      const x = n.value.appliedData;
+      b.query && x && i.canRestoreQuery ? i.restoreQuery({ ...x, query: b.query }, C) : i.restoreView(b, C);
+      const N = await i.restore(b, b.url, C);
+      N === "restored" && C.isCurrent() && (i.select(b.selected, C), v.value === b && (v.value = void 0));
+      const ge = {
+        status: N === "restored" ? "applied" : N
+      };
+      return F.finish(ge), ge;
+    } catch (x) {
+      if (!C.isCurrent())
+        return U(F.operation);
+      throw n.fail(pe, "columns", x), F.fail(x), s.presentError(x), x;
+    } finally {
+      F.finish(
+        C.isCurrent() ? { status: "applied" } : U(F.operation)
+      ), G(), n.finish(pe, !v.value), H === h && (H = void 0, w.value !== "failed" && v.value === b && !C.isCurrent() && (v.value = void 0));
+    }
+  }
+  const rt = D(() => n.value.requestedData), at = D(() => n.value.appliedData), nt = D(() => n.value.failure), Ee = D(
+    () => w.value === "failed" && g() && !!a.table.value && a.isInitDone.value
+  );
+  let te;
+  function it() {
+    if (te) return te;
+    if (!Ee.value) return Promise.resolve({ status: "superseded" });
+    const e = n.value.failure;
+    s.resetErrors?.();
+    const t = a.table.value, r = e.kind === "rebuild" ? I() : e.kind === "filters" && !n.value.snapshot?.query ? qe(t, n.value.desired.url, void 0, {
+      value: n.value.desired.context
+    }).command.result : Re(t), l = c, u = y;
+    return te = (async () => (await r, new Promise((i, f) => {
+      let o = () => {
+      };
+      const p = () => {
+        !g() || l !== c || u !== y ? (o(), i({ status: P.value ? "cancelled" : "superseded" })) : w.value === "failed" ? (o(), f(n.value.failure.cause)) : (w.value === "ready" || w.value === "idle") && (o(), i({
+          status: w.value === "ready" ? "applied" : "superseded"
+        }));
+      };
+      o = gt(n.state, p, { flush: "sync" }), p();
+    })))().finally(() => {
+      te = void 0;
+    }), te;
+  }
+  function st() {
+    P.value || (n.setActive(!1), W.pause(), ee(), s.resetErrors?.(), (m || E || B) && (V.value ??= "apply", m ??= E ?? B));
+  }
+  function lt() {
+    return P.value || J.value ? Promise.resolve() : (n.setActive(!0), W.resume(), ve());
+  }
+  function ut() {
+    P.value || (n.dispose(), W.dispose(), k(), ee(), m = void 0, v.value = void 0, a.table.value = null, s.resetErrors?.());
+  }
+  return {
+    status: w,
+    error: nt,
+    canRetry: Ee,
+    retry: it,
+    canApplyColumns: ze,
+    columnsApplying: re(Se),
+    applyColumns: tt,
+    active: re(J),
+    disposed: re(P),
+    phase: re(ie),
+    preparing: re(me),
+    rebuilding: L,
+    pending: v,
+    superseded: Ce,
+    get generation() {
+      return c;
+    },
+    get revision() {
+      return y;
+    },
+    get requestSequence() {
+      return _;
+    },
+    get acceptedUrl() {
+      return E?.generation === c && E.revision === y ? E.url : void 0;
+    },
+    requestedData: rt,
+    appliedData: at,
+    beginRequest: Je,
+    requestFailed: Pe,
+    requestStopped: Ke,
+    acceptResponse: _e,
+    isResponseCurrent: Be,
+    responseApplied: He,
+    responseTransformed: Te,
+    responseFailed(e, t) {
+      const r = e && typeof e == "object" ? $.get(e) : void 0;
+      r && Pe(r, t);
+    },
+    isTrackedResponse: (e) => !!e && typeof e == "object" && $.has(e),
+    rebuild: I,
+    localeChanged: Ne,
+    quickFilterChanged: Ye,
+    tableKeyChanged: Xe,
+    startReady: ve,
+    tableReady: et,
+    apply: Ue,
+    executeFilters: Ze,
+    deactivate: st,
+    activate: lt,
+    dispose: ut,
+    trackRestore: oe.track,
+    invalidateRequests() {
+      _++;
+    }
+  };
+}
+export {
+  Lt as createTableLifecycle,
+  Me as createTableRestoreOperation,
+  wt as waitForTablePreparation
+};