rest-client-vue 1.0.0-a1

package/dist/rest-client-vue.js

@@ -0,0 +1,1254 @@
+var we = Object.defineProperty;
+var Ce = (f, s, R) => s in f ? we(f, s, { enumerable: !0, configurable: !0, writable: !0, value: R }) : f[s] = R;
+var re = (f, s, R) => (Ce(f, typeof s != "symbol" ? s + "" : s, R), R), Te = (f, s, R) => {
+  if (!s.has(f))
+    throw TypeError("Cannot " + R);
+};
+var Q = (f, s, R) => (Te(f, s, "read from private field"), R ? R.call(f) : s.get(f)), Se = (f, s, R) => {
+  if (s.has(f))
+    throw TypeError("Cannot add the same private member more than once");
+  s instanceof WeakSet ? s.add(f) : s.set(f, R);
+};
+import a from "lodash";
+import { v4 as X } from "uuid";
+import { ref as I, toRef as te, computed as m, watch as C, nextTick as Le } from "vue";
+import P from "axios";
+import me from "jsog";
+import V from "json-stringify-deterministic";
+import { defineStore as ye } from "pinia";
+const pe = {
+  apiBaseUrl: "",
+  useVueLogger: !1
+};
+class ke extends Error {
+  constructor(R, L = void 0, e = void 0) {
+    super(R);
+    re(this, "context");
+    re(this, "innerError");
+    this.context = L, this.innerError = e;
+  }
+}
+var O;
+class Ie {
+  constructor() {
+    Se(this, O, {});
+  }
+  clearAllStores() {
+    for (const s in Q(this, O))
+      Q(this, O)[s].clear();
+  }
+  destroyStore(s) {
+    Q(this, O)[s] && (Q(this, O)[s].$dispose(), delete Q(this, O)[s]);
+  }
+  getStore(s) {
+    return Q(this, O)[s];
+  }
+  registerStore(s, R) {
+    Q(this, O)[s] = R;
+  }
+}
+O = new WeakMap();
+function v(f, s) {
+  return a.get(f, (s == null ? void 0 : s.idProperty) || "_id");
+}
+function $e(f, s) {
+  var R;
+  return f && ((R = s.filter) != null && R.resourceIds) && !s.order ? s.filter.resourceIds.map((L) => f.find((e) => v(e, s) == L)).filter((L) => L != null) : f;
+}
+const De = {
+  detail: {
+    allowMultiple: !0,
+    autoEdit: !1,
+    autoFromMultipleSelection: !0,
+    autoFromSingleInsertion: !0,
+    autoFromSingleSelection: !0,
+    constrainToSelection: !0
+  },
+  filter: {
+    namedFilter: null,
+    query: null,
+    resourceIds: null
+  },
+  idProperty: "_id",
+  limit: 5e3,
+  limitTransientDataToLocalCollection: !0,
+  loading: {
+    firstPageSize: 500,
+    pageSize: 5e3
+  },
+  order: [
+    // TODO Move to SFA LIMS.
+    [{ path: "history.creation.timestamp" }, "desc"],
+    [{ path: "history.creation.orderInBatch" }, "desc"]
+  ]
+}, Y = {
+  resources: [],
+  status: "NotLoaded",
+  selection: [],
+  detailSelection: [],
+  invalidResources: [],
+  transientData: {}
+}, le = {
+  editingDetailSelection: !1,
+  batchSaveAttempted: !1,
+  editors: [],
+  listNavigators: {}
+}, Pe = (f, s) => {
+  s = a.merge({}, De, s);
+  const R = ye(f, {
+    state: () => ({
+      idProperty: s.idProperty,
+      filter: s.filter,
+      order: s.order || null,
+      referencePathsToExpand: s.referencePathsToExpand || null,
+      ...Y,
+      ...le
+    }),
+    getters: {
+      /**
+       * Get the REST query parameters that can be determined from the collection options.
+       *
+       * This includes all query parameters except offset and limit, which vary from request to request.
+       */
+      fixedQueryParams: (e) => {
+        var l, u, c, d;
+        const r = {};
+        (l = e.filter) != null && l.namedFilter && (r.namedFilter = e.filter.namedFilter);
+        const t = [];
+        if ((u = e.filter) != null && u.resourceIds && t.push({ l: { path: e.idProperty }, r: { constant: e.filter.resourceIds }, operator: "in" }), (c = e.filter) != null && c.query && t.push((d = e.filter) == null ? void 0 : d.query), t.length > 0) {
+          const y = t.length == 1 ? t[0] : { and: t };
+          r.q = V(y);
+        }
+        return e.order && (r.o = V(e.order)), e.referencePathsToExpand && (r.r = V(e.referencePathsToExpand)), r;
+      }
+    },
+    actions: {
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // Actions: Configuration
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      /**
+       * Reset the store to its initial state.
+       *
+       * Configuration is retained, but REST collection contents and contextual state are reset.
+       */
+      reset() {
+        for (const e in Y)
+          this[e] = Y[e];
+        for (const e in le)
+          this[e] = le[e];
+      },
+      /**
+       * Reset the store to its initial state, but retain transient data if appropriate.
+       *
+       * As with {@link reset}, configuration is retained, but REST collection contents and contextual state are reset.
+       * Transient data are retained if options.limitTransientDataToLocalCollection is false.
+       */
+      resetRetainingTransientData() {
+        if (s.limitTransientDataToLocalCollection)
+          this.reset();
+        else {
+          const e = this.transientData;
+          this.reset(), this.transientData = e;
+        }
+      },
+      /**
+       * Turn editing mode on or off for the current detail selection.
+       *
+       * Components using this store use the editingDetailSelection state property to govern whether to show an editor for
+       * any current detail selection.
+       *
+       * @param editingDetailSelection The new setting: true if an the detail selection should be shown in an editor,
+       *   false if not.
+       */
+      setEditingDetailSelection(e) {
+        this.editingDetailSelection = e;
+      },
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // Actions: Filtering the local collection
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      /**
+       * Set the filter.
+       *
+       * This function sets the whole filter without triggering a reload of the local collection. More commonly, clients
+       * will call {@link setQuery} or {@link setFilterResourceIds}.
+       *
+       * @param filter The new filter.
+       */
+      setFilter(e) {
+        a.isEqual(e, this.filter) || (this.filter = e, this.status = "NotLoaded", this.resources = [], this.selection = [], this.detailSelection = [], this.invalidResources = [], this.editingDetailSelection = !1);
+      },
+      /**
+       * Set the filter query.
+       *
+       * If the collection has a state other than NotLoaded, it will be reloaded.
+       *
+       * @param query The new filter query.
+       * @return A promise that resolves when {@link loadResources} completes, or immediately if the collection does not
+       *   need to be reloaded.
+       */
+      async setQuery(e) {
+        var r, t;
+        if (!a.isEqual(e, (r = this.filter) == null ? void 0 : r.query) && (e != null || ((t = this.filter) == null ? void 0 : t.query) != null)) {
+          const l = a.cloneDeep(this.filter) || {};
+          e !== null ? l.query = e : a.unset(l, "query");
+          const u = this.status;
+          this.setFilter(l), u != "NotLoaded" && await this.loadResources();
+        }
+      },
+      /**
+       * Set the list if resource IDs to filter on.
+       *
+       * If the collection has a state other than NotLoaded, it will be reloaded.
+       *
+       * @param resourceIds The list of resource IDs for the new filter.
+       * @return A promise that resolves when {@link loadResources} completes, or immediately if the collection does not
+       *   need to be reloaded.
+       */
+      async setFilterResourceIds(e) {
+        if (!a.isEqual(e, a.get(this.filter, "resourceIds"))) {
+          const r = a.cloneDeep(this.filter) || {};
+          e != null ? r.resourceIds = e : a.unset(r, "resourceIds");
+          const t = this.status;
+          this.setFilter(r), t != "NotLoaded" && await this.loadResources();
+        }
+      },
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // Actions: Status
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      /**
+       * Indicate that a batch save has been attempted and failed.
+       *
+       * Setting this flag is a way of communicating with other client code. The flag should be cleared after further
+       * edits or when another validation or save operations is attempted.
+       *
+       * @param batchSaveAttempted A flag indicating whether a batch save has been attempted and failed.
+       */
+      setBatchSaveAttempted(e) {
+        e != this.batchSaveAttempted && (this.batchSaveAttempted = e);
+      },
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // Actions: Loading and unloading the collection
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      /**
+       * Clear the collection's contents.
+       *
+       * Configuration and contextual state are retained, but REST collection contents are reset.
+       */
+      clear() {
+        for (const e in Y)
+          this[e] = Y[e];
+      },
+      /**
+       * Clear the collection's contents, but retain transient data if appropriate.
+       *
+       * As with {@link reset}, configuration and contextual state are retained, but REST collection contents are reset.
+       * Transient data are retained if options.limitTransientDataToLocalCollection is false.
+       */
+      clearRetainingTransientData() {
+        if (s.limitTransientDataToLocalCollection)
+          this.reset();
+        else {
+          const e = this.transientData;
+          this.reset(), this.transientData = e;
+        }
+      },
+      /**
+       * Load the collection, if it has not been loaded.
+       *
+       * The collection will be loaded if its current status is not Loaded, Loading, LoadingMore, or Failed.
+       */
+      async ensureCollectionLoaded() {
+        ["Loaded", "Loading", "LoadingMore", "Failed"].includes(this.status) || await this.loadResources();
+      },
+      /**
+       * Load the collection.
+       *
+       * If pagination is enabled, this may result in multiple HTTP requests. The function's Promise is resolved once
+       * the first page is loaded.
+       *
+       * @param loadOptions Pagination options that may override the defaults.
+       */
+      async loadResources(e = {}) {
+        this.resetRetainingTransientData();
+        const r = X();
+        this._loadId = r, await this._loadResources(0, r, e);
+      },
+      /**
+       * Load the collection, optionally starting at some offset.
+       *
+       * If pagination is enabled, this may result in multiple HTTP requests. The function's Promise is resolved once
+       * the first page is loaded.
+       *
+       * @param offset The offset at which to start loading. When loading a whole collection, this will be 0; but if
+       *   there are more pages to load, the function will call itself with the next page offset.
+       * @param loadId A unique identifier for this load operation, which is used to detect whether results should be
+       *   discarded because a later load operation has been issued. Before calling this method, this identifier should
+       *   be written to the store's state property named loadId.
+       * @param loadOptions Pagination options that may override the defaults.
+       */
+      async _loadResources(e, r, t) {
+        var b, q, A, z, B;
+        const l = e == 0;
+        if (this.status = l ? "Loading" : "LoadingMore", this._loadOffset = e, ((b = this.filter) == null ? void 0 : b.query) === !1) {
+          this.resources = [];
+          return;
+        }
+        const u = this.fixedQueryParams, c = a.cloneDeep(u), d = l ? (q = this.filter) != null && q.resourceIds && !this.order ? null : t.firstPageSize || ((A = s.loading) == null ? void 0 : A.firstPageSize) || t.pageSize || ((z = s.loading) == null ? void 0 : z.pageSize) || null : t.pageSize || ((B = s.loading) == null ? void 0 : B.pageSize) || null, y = d != null || s.limit != null ? a.min(a.filter([d, s.limit], (g) => g != null)) : void 0;
+        y != null ? (c.offset = e, c.limit = y) : e != 0 && (c.offset = e);
+        const U = a.map(
+          c,
+          (g, S) => g != null ? `${encodeURIComponent(S)}=${encodeURIComponent(g)}` : null
+        ).filter((g) => g != null).join("&"), T = a.isEmpty(U) ? s.restCollectionUrl : `${s.restCollectionUrl}?${U}`;
+        try {
+          const g = await P.get(T), S = this.fixedQueryParams;
+          if (r != this._loadId || e != this._loadOffset || !a.isEqual(u, S))
+            console.log(`Discarding resources fetched by obsolete query from ${s.restCollectionUrl}.`);
+          else {
+            const E = me.decode(a.get(g, "data.data", [])), $ = (l ? 0 : this.resources.length) + E.length, D = y == null || E.length < y || s.limit && $ >= s.limit;
+            console.log(
+              `Loaded ${E.length}${l ? "" : " more"} resources from ${s.restCollectionUrl}`
+            ), l && (this.resources = []);
+            const W = [...this.resources, ...E.map((H) => Object.freeze(H))];
+            this.resources = $e(W, this), this.status = D ? "Loaded" : "LoadingMore", D || this._loadResources(this.resources.length, r, t);
+          }
+        } catch (g) {
+          console.log(`Error while loading resources (URL="${T}"):`, g), this.clearRetainingTransientData(), this.status = "Failed";
+        }
+      },
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // Actions: Recording modifications to the collection
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      /**
+       * Verify that a resource does not exist in the remote collection.
+       *
+       * After checking the remote collection and verifying that the resource does not exist, this function calls
+       * {@link recordDeletion} to delete it from the local collection.
+       *
+       * @param itemId The ID of the deleted resource to check.
+       * @return true if the record does not exist in the remote collection, false if it does or if an error occurred.
+       */
+      async checkForDeletedResource(e) {
+        let r;
+        try {
+          r = await P.get(`${s.restCollectionUrl}/${e}`);
+        } catch (t) {
+          P.isAxiosError(t) && (r = t.response);
+        }
+        return r && r.status == 404 ? (this.recordDeletion(e), !0) : !1;
+      },
+      /**
+       * Record a deletion, removing the deleted resource from the local collection.
+       *
+       * This should be called after deleting a resource from the remote collection. It is called, for instance, by
+       * {@link deleteResource}; but it can also be called when the application is aware of deletions from the remote
+       * collection made by other means.
+       *
+       * @param resourceId The ID of the resource that has been deleted.
+       */
+      recordDeletion(e) {
+        var r;
+        if (["Loaded", "LoadingMore"].includes(this.status)) {
+          let t = this.resources.findIndex((l) => v(l, this) == e);
+          t >= 0 && this.resources.splice(t, 1), t = this.selection.findIndex((l) => v(l, this) == e), t >= 0 && this.selection.splice(t, 1), t = this.detailSelection.findIndex((l) => v(l, this) == e), t >= 0 && (this.detailSelection.splice(t, 1), this.detailSelection.length == 0 && (this.editingDetailSelection = ((r = s.detail) == null ? void 0 : r.autoEdit) || !1)), s.limitTransientDataToLocalCollection && delete this.transientData[e];
+        }
+      },
+      /**
+       * Record an insertion, adding the inserted resource to the local collection.
+       *
+       * This should be called after inserting a resource into the remote collection. It is called, for instance, by
+       * {@link saveResource}; but it can also be called when the application is aware of insertions into the remote
+       * collection made by other means.
+       *
+       * It is important that the resources to be added to the local collection have the same object-graph
+       * characteristics as other resources in the local collection. (These characteristics include property inclusions
+       * and exclusions, as well as reference expansions.) To ensure this, you may call {@refreshResource} to fetch the
+       * resource using the collection's settings.
+       *
+       * @param resource The item that has been inserted.
+       * @param TODO
+       */
+      recordInsertion(e, { insertAtBeginning: r, transientData: t } = {}) {
+        var l;
+        if (["Loaded", "LoadingMore"].includes(this.status)) {
+          const u = Object.freeze(e);
+          r ? this.resources.unshift(u) : this.resources.push(u), (l = s.detail) != null && l.autoFromSingleInsertion && (this.detailSelection.length == 0 || this.detailSelection.length == 1 && v(this.detailSelection[0], this) == null) && (this.detailSelection = [u], this.editingDetailSelection = s.detail.autoEdit);
+          const c = v(e, this);
+          c && (t === void 0 ? delete this.transientData[c] : this.transientData[c] = t);
+        }
+      },
+      /**
+       * Record an update, making the same changes in the local collection.
+       *
+       * This should be called after updating a resource in the remote collection. It is called, for instance, by
+       * {@link saveResource} and {@link refreshResource}; but it can also be called when the application is aware of
+       * updates in the remote collection made by other means.
+       *
+       * It is important that the resource have the same object-graph characteristics as other resources in the local
+       * collection. (These characteristics include property inclusions and exclusions, as well as reference
+       * expansions.) To ensure this, you may instead call {@refreshResource} to fetch the  resource using the
+       * collection's settings; this will in turn call {@link recordUpdate}.
+       *
+       * @param resource The item that has been updated.
+       */
+      recordUpdate(e) {
+        const r = v(e, this);
+        if (r && ["Loaded", "LoadingMore"].includes(this.status)) {
+          const t = Object.freeze(e);
+          let l = this.resources.findIndex((u) => v(u, this) == r);
+          l >= 0 && (this.resources[l] = t), l = this.selection.findIndex((u) => v(u, this) == r), l >= 0 && (this.selection[l] = t), l = this.detailSelection.findIndex((u) => v(u, this) == r), l >= 0 && (this.detailSelection[l] = t);
+        }
+      },
+      /**
+       * Refresh a resource by requesting it from the remote collection.
+       *
+       * If the resource already exists in the local collection, {@link recordUpdate} will be called to update it there.
+       * If not, this method will return the resource but will not add it to the collection.
+       *
+       * This function is called by {@link insertItem} and {@link updateItem} to ensure that the local copy of the added
+       * or updated resource has the same object-graph characteristics as the rest of the local collection.
+       *
+       * @param resourceId The ID of the resource to refresh.
+       * @return The refreshed resource, or null if refreshing failed.
+       */
+      async refreshResource(e) {
+        if (e) {
+          const r = {};
+          this.referencePathsToExpand && (r.r = V(this.referencePathsToExpand));
+          const t = a.map(
+            r,
+            (c, d) => c != null ? `${encodeURIComponent(d)}=${encodeURIComponent(c)}` : null
+          ).filter((c) => c != null).join("&"), l = a.isEmpty(t) ? `${s.restCollectionUrl}/${e}` : `${s.restCollectionUrl}/${e}?${t}`, u = await P.get(l);
+          if (u.status == 200) {
+            const c = u.data;
+            return this.recordUpdate(c), c;
+          }
+        }
+        return null;
+      },
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // Actions: Modifying the collection
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      /**
+       * Insert a new unsaved resource into the local collection and enter editing mode.
+       *
+       * @param resourceDefaults Initial properties of the new resource.
+       */
+      addResource(e = {}) {
+        this.detailSelection = [a.omit(a.merge({}, e), this.idProperty)], this.editingDetailSelection = !0;
+      },
+      /**
+       * Delete one resource.
+       *
+       * A delete request is sent to the REST API. If it succeeds, the resource is removed from the local collection.
+       *
+       * @param resourceId The ID of the resource to delete.
+       */
+      async deleteResource(e) {
+        if ((await P.delete(`${s.restCollectionUrl}/${e}`)).status == 200 && ["Loaded", "LoadingMore"].includes(this.status)) {
+          let t = this.resources.findIndex((l) => v(l, this) == e);
+          t >= 0 && this.resources.splice(t, 1), t = this.selection.findIndex((l) => v(l, this) == e), t >= 0 && this.selection.splice(t, 1), t = this.detailSelection.findIndex((l) => v(l, this) == e), t >= 0 && (this.detailSelection.splice(t, 1), this.detailSelection.length == 0 && (this.editingDetailSelection = s.detail.autoEdit)), s.limitTransientDataToLocalCollection && delete this.transientData[e];
+        }
+      },
+      /**
+       * Write a new or updated resource to the remote collection, then mirror the change in the local collection.
+       *
+       * After writing changes, {@link refreshResource} is called to ensure that the local resource (which is also the
+       * return value) has the same object-graph characteristics as the rest of the local collection.
+       *
+       * @param resource The new or updated resource. If it has an ID, an update will be attempted; otherwise it will be
+       *   created.
+       * @returns The refreshed local resource after the change has been persisted to the remote collection, or null if
+       *   the operation failed.
+       */
+      async saveResource(e) {
+        const r = v(e, this), t = r == null, l = await P({
+          method: t ? "post" : "put",
+          url: t ? s.restCollectionUrl : `${s.restCollectionUrl}/${r}`,
+          data: e
+        });
+        if (l.status == 200) {
+          const u = l.data, c = v(u, this), d = c ? await this.refreshResource(c) : null;
+          return t && this.recordInsertion(d || Object.freeze(u)), d || u;
+        }
+        return null;
+      },
+      /**
+       * Write new and/or updated resources to the remote collection, and mirror the changes in the local collection.
+       *
+       * After writing changes, {@link refreshResource} is called to ensure that the local resource (which is also the
+       * return value) has the same object-graph characteristics as the rest of the local collection.
+       *
+       * @param resources Resources to create or update. The two operations may be mixed in the list; when a resource
+       *   has an ID, an update will be attempted, while otherwise it will be added.
+       * @returns An array of refreshed local resources, one for each remote resource whose save operation succeeded.
+       */
+      async saveResources(e) {
+        const r = await P({
+          method: "put",
+          url: s.restCollectionUrl,
+          data: e
+        });
+        if (r.status == 200) {
+          const t = r.data || [], l = [];
+          for (const [u, c] of t.entries()) {
+            const d = v(e[u], this) == null, y = v(c, this), U = y ? await this.refreshResource(y) : null;
+            d && this.recordInsertion(U || c), l.push(U || Object.freeze(c));
+          }
+          return l;
+        }
+        return [];
+      },
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // Actions: Transient data
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      /** Clear all transient data. */
+      clearTransientData() {
+        this.transientData = {};
+      },
+      /**
+       * Record which local resources currently fail validation.
+       *
+       * This is useful in multi-resource editing contexts.
+       *
+       * @param resourceIds The IDs of all local resources that failed validation.
+       */
+      setInvalidResourceIds(e) {
+        a.isEqual(e, this.invalidResources.map((r) => v(r, this))) || (this.invalidResources = e.map((r) => this.resources.find((t) => v(t, this) == r)).filter((r) => r != null));
+      },
+      /**
+       * Set transient data.
+       *
+       * @param transientData The new transient data.
+       * @param merge If true, combine each resource's transient data with existing transient data; if false, replace
+       *   the transient data for each resource ID in the keys of transientData. 
+       */
+      setTransientDataForResources(e) {
+        const { transientData: r, merge: t = !0 } = e;
+        t ? a.merge(this.transientData, r) : a.assign(this.transientData, r);
+      },
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // Actions: Managing selections
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      /**
+       * Clear the selection.
+       */
+      clearSelection() {
+        this.setSelection([]);
+      },
+      /**
+       * Remove resources from the selection.
+       *
+       * @param resourceIds The IDs of resources to remove from the selection. 
+       */
+      deselectResources(e) {
+        const r = this.selection.map((t) => v(t, this)).filter((t) => t != null && !e.includes(t));
+        this.setSelection(r);
+      },
+      /**
+       * Add to or replace the selection.
+       *
+       * @param recordIds The record IDs to select.
+       * @param addToSelection true if the existing selection should be expanded, false if it should be replaced.
+       * @param edit If not undefined, sets the editing mode of the new selection. If undefined, the editing mode will
+       *   be left as is, or set to true if options.detail.autoEdit is true.
+       */
+      selectResources(e, r) {
+        const { addToSelection: t, edit: l } = r || {}, u = this.selection.map((d) => v(d, this));
+        let c = e;
+        if (t) {
+          const d = a.difference(e, u);
+          d.length > 0 && (c = u.concat(d).filter((y) => y != null));
+        }
+        a.isEqual(u, c) || this.setSelection(c, l);
+      },
+      /**
+       * Set a new selection.
+       *
+       * @param selectedResourceIds The resource IDs in the new selection.
+       * @param edit If not undefined, sets the editing mode of the new selection. If undefined, the editing mode will
+       *   be left as is, or set to true if options.detail.autoEdit is true.
+       */
+      setSelection(e, r) {
+        if (!a.isEqual(e, this.selection.map((t) => v(t, this)))) {
+          let t = !0;
+          if (this.editors.length > 0) {
+            if (s.detail.autoFromSingleSelection && this.selection.length == 1)
+              t = !1;
+            else if (s.detail.autoFromMultipleSelection && s.detail.allowMultiple && this.selection.length > 1)
+              t = !1;
+            else if (s.detail.constrainToSelection) {
+              const l = this.selection.map((d) => v(d, this)), c = this.detailSelection.map((d) => v(d, this)).filter((d) => l.includes(d));
+              this.detailSelection.filter((d) => !c.includes(v(d, this))).length > 0 && (t = !1);
+            }
+          }
+          if (!t)
+            return;
+          if (this.selection = e.map((l) => this.resources.find((u) => v(u, this) == l)).filter((l) => l != null), s.detail.autoFromSingleSelection && this.selection.length == 1) {
+            const l = this.selection[0];
+            (this.detailSelection.length != 1 || v(this.detailSelection[0], this) != v(l, this)) && (this.detailSelection = [l]);
+          } else if (s.detail.autoFromMultipleSelection && s.detail.allowMultiple && this.selection.length > 1)
+            a.isEqual(
+              this.selection.map((l) => v(l, this)),
+              this.detailSelection.map((l) => v(l, this))
+            ) || (this.detailSelection = a.clone(this.selection));
+          else if (s.detail.constrainToSelection) {
+            const l = this.selection.map((d) => v(d, this)), u = this.detailSelection.map((d) => v(d, this)), c = u.filter((d) => l.includes(d));
+            a.isEqual(c, u) || (this.detailSelection = this.detailSelection.filter((d) => c.includes(v(d, this))));
+          }
+          this.detailSelection.length == 0 ? this.editingDetailSelection = !1 : this.editingDetailSelection = r !== void 0 ? r : this.editingDetailSelection || s.detail.autoEdit;
+        }
+      },
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // Actions: Managing the detail view
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      /**
+       * Hide the detail view.
+       *
+       * This clears detailSelection and sets the detail editing mode to false.
+       */
+      hideDetail() {
+        this.detailSelection.length > 0 && (this.detailSelection = [], this.editingDetailSelection = !1);
+      },
+      /**
+       * Show the current selection in the detail view.
+       *
+       * If options.detail.allowMultiple is false and more than one resource is selected, the detail view will not be
+       * changed.
+       *
+       * @param edit If not undefined, sets the detail editing mode. If undefined, the editing mode will be left as is,
+       *   or set to true if options.detail.autoEdit is true.
+       */
+      showSelectionAsDetail(e) {
+        if (this.selection.length <= 1 || s.detail.allowMultiple) {
+          const r = this.selection.map((l) => v(l, this)), t = this.detailSelection.map((l) => v(l, this));
+          a.isEqual(r, t) || (this.detailSelection = a.clone(this.selection)), this.detailSelection.length == 0 ? this.editingDetailSelection = !1 : this.editingDetailSelection = e !== void 0 ? e : this.editingDetailSelection || s.detail.autoEdit;
+        }
+      },
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // Actions: Tracking editors
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      /**
+       * Deregister an editor.
+       *
+       * @param editor The editor to deregister.
+       */
+      deregisterEditor(e) {
+        a.remove(this.editors, (r) => r == e);
+      },
+      /**
+       * Register an editor.
+       *
+       * @param editor The editor to register.
+       */
+      registerEditor(e) {
+        this.editors.includes(e) || this.editors.push(e);
+      },
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // Actions: Tracking list navigators
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      /**
+       * Deregister a list navigator.
+       *
+       * @param name The name of the list navigator to deregister.
+       * @param listNavigator The list navigator. If defined, the named list navigator will only be deleted if it equals
+       *   this parameter.
+       */
+      deregisterListNavigator({ name: e, listNavigator: r }) {
+        (r == null || this.listNavigators[e] == r) && delete this.listNavigators[e];
+      },
+      /**
+       * Register a list navigator.
+       *
+       * Registering a component such as a list view as a list navigator can help other components with list navigation.
+       * For instance, code that implements a "next" button in a detail view might use the list navigator to determine
+       * what resource to select next.
+       *
+       * If another list navigator is registered under this name, its registration will be replaced.
+       *
+       * @param name The name under which to register the list navigator.
+       * @param listNavigator The list navigator.
+       */
+      registerListNavigator({ name: e, listNavigator: r }) {
+        this.listNavigators[e] != r && (this.listNavigators[e] = r);
+      }
+    }
+  });
+  return (() => {
+    const e = (r, t) => {
+      const l = R(r, t);
+      return ie.registerStore(l.$id, l), l;
+    };
+    return e.$id = R.$id, e;
+  })();
+}, ie = new Ie(), Be = (f = {}) => {
+  var oe, ce, ue, de;
+  const {
+    collectionId: s,
+    draftBatchId: R,
+    enabled: L,
+    resourceType: e,
+    options: r
+  } = f, t = I(void 0), l = I(s), u = I(R), c = I(L ?? !0), d = I([te(e)]), y = I(r), U = m(() => u.value), T = I(c.value), b = I(X()), q = I((ce = (oe = y.value) == null ? void 0 : oe.filter) == null ? void 0 : ce.resourceIds), A = I((de = (ue = y.value) == null ? void 0 : ue.filter) == null ? void 0 : de.query), z = m(
+    () => u.value == null && l.value != null && ie.getStore(l.value) != null
+  ), B = I(z.value), g = m(() => $("status", "Uninitialized"));
+  function S(i) {
+    if (t.value)
+      return i(t.value);
+  }
+  async function E(i) {
+    if (t.value)
+      return await i(t.value);
+  }
+  function $(i, o) {
+    if (t.value)
+      return t.value[i];
+    if (o !== void 0)
+      return o;
+    throw "Attempted to use a REST collection store that has not been created, with no default value.";
+  }
+  const D = (i = {}) => {
+    var fe, ve, ge, Re;
+    const {
+      collectionId: o,
+      draftBatchId: w,
+      enabled: _,
+      resourceType: se,
+      options: he
+    } = i;
+    l.value = o, u.value = w, c.value = _ ?? !0, d.value = [te(se)], he != null && (y.value = he, q.value = (ve = (fe = y.value) == null ? void 0 : fe.filter) == null ? void 0 : ve.resourceIds, A.value = (Re = (ge = y.value) == null ? void 0 : ge.filter) == null ? void 0 : Re.query), b.value = X(), W(c.value);
+  }, W = async (i) => {
+    i != T.value && (T.value = i, i && (K(), N()));
+  }, H = async (i) => {
+    q.value = i, await E(async (o) => await o.setFilterResourceIds(q.value || null));
+  }, J = async (i) => {
+    if (A.value = i, g.value != "Uninitialized") {
+      const o = i, w = m(() => a.isFunction(o) ? p.value ? o(p.value) : null : o);
+      await E((_) => _.setQuery(w.value || null));
+    }
+  }, K = () => {
+    y.value = a.merge({}, y.value || {}, {
+      filter: { resourceIds: q.value, query: A.value }
+    });
+  }, p = m(
+    () => d.value[0].value || void 0
+  ), k = function(i) {
+    const o = a.get(i, "filter.query"), w = a.get(i, "referencePathsToExpand"), _ = a.isFunction(o) ? o(p.value) : o, se = p.value ? a.isFunction(w) ? w(p.value) : w || [] : [];
+    return {
+      ...a.cloneDeep(i || {}),
+      filter: {
+        ...a.cloneDeep((i == null ? void 0 : i.filter) || {}),
+        query: _
+      },
+      referencePathsToExpand: se
+    };
+  }, x = m(() => k(y.value)), M = m(() => {
+    if (!p.value)
+      return null;
+    if (x.value.restCollectionUrl !== void 0)
+      return x.value.restCollectionUrl;
+    if (!B.value)
+      return !p.value || !p.value.collectionName ? null : U.value ? `${ee.config.apiBaseUrl}/draft-batches/${U.value}/${p.value.collectionName}` : `${ee.config.apiBaseUrl}/${p.value.collectionName}`;
+  }), n = m(() => {
+    var i;
+    if (p.value)
+      return a.mergeWith(
+        a.cloneDeep(De),
+        x.value,
+        {
+          idProperty: (i = p.value) == null ? void 0 : i.idProperty,
+          restCollectionUrl: M.value || ""
+        },
+        (o, w) => {
+          if (a.isArray(w) && w.length == 0 && (o == null || a.isArray(o)))
+            return w;
+        }
+      );
+  }), h = I(0), F = m(
+    () => {
+      var i;
+      return h.value, l.value || p.value && ((i = p.value) == null ? void 0 : i.collectionName) && (U.value ? `draftBatches/${U.value}/${p.value.collectionName}/${b.value}` : `${p.value.collectionName}/${b.value}`) || null;
+    }
+  ), N = () => {
+    if (T.value) {
+      let i = !1;
+      return p.value && F.value && (t.value = ie.getStore(F.value), t.value ? i = !1 : n.value && (B.value = !1, t.value = Pe(F.value, n.value)(), i = !0)), i;
+    } else
+      return !1;
+  }, G = () => {
+    F.value && l.value == F.value ? (t.value = void 0, N()) : (t.value = void 0, h.value = h.value + 1, N());
+  };
+  C(U, (i, o) => {
+    a.isEqual(i, o) || G();
+  }), C(T, (i, o) => {
+    i != o && (i ? N() : t.value = void 0);
+  }), C(p, (i, o) => {
+    i && !o ? N() : !i && o || a.isEqual(i, o) || G();
+  }), C(n, (i, o) => {
+    a.isEqual(i, o) || G();
+  }), C(z, () => {
+    z.value || (B.value = !1);
+  }), C(F, () => N()), C(M, (i, o) => {
+    a.isEqual(i, o) || G();
+  });
+  const j = [], Ee = function(i) {
+    g.value != "Uninitialized" ? Le(i) : j.push(i);
+  };
+  return C(g, (i, o) => {
+    if (i != "Uninitialized" && o == "Uninitialized") {
+      const w = a.clone(j);
+      j.splice(0, j.length);
+      for (const _ of w)
+        _();
+    }
+  }), N(), {
+    // Configuration
+    collectionId: F,
+    draftBatchId: U,
+    resourceType: p,
+    // Status
+    enabled: T,
+    status: g,
+    batchSaveAttempted: m(() => $("batchSaveAttempted", !1)),
+    // Resources loaded from the REST API
+    invalidResources: m(() => $("invalidResources", [])),
+    resources: m(() => g.value != "Uninitialized" ? (E((i) => i.ensureCollectionLoaded()), $("resources", [])) : []),
+    // Transient data
+    transientData: m(() => $("transientData", [])),
+    // Selection and detail selection
+    detailSelection: m(() => $("detailSelection", [])),
+    editingDetailSelection: m(() => $("editingDetailSelection", !1)),
+    selection: m(() => $("selection", [])),
+    // Methods: Configuration
+    reconfigureCollection: D,
+    setEditingDetailSelection: (i) => S(
+      (o) => o.setEditingDetailSelection(i)
+    ),
+    setEnabled: W,
+    setFilterResourceIds: H,
+    setQuery: J,
+    // Methods: Status
+    ensureStore: N,
+    // TODO Rename
+    setBatchSaveAttempted: (i) => S((o) => o.setBatchSaveAttempted(i)),
+    // Local collection management
+    clear: () => S((i) => i.clear()),
+    ensureCollectionLoaded: async () => await E(async (i) => i.ensureCollectionLoaded()),
+    loadResources: async () => await E(async (i) => await i.loadResources()),
+    // Methods: Recording changes to the collection
+    addResource: (i) => S((o) => o.addResource(i)),
+    checkForDeletedResource: async (i) => await E(async (o) => await o.checkForDeletedResource(i)) == !0,
+    recordDeletion: (i) => S((o) => o.recordDeletion(i)),
+    recordInsertion: (i, { insertAtBeginning: o = !1, transientData: w = void 0 } = {}) => S((_) => _.recordInsertion(i, { insertAtBeginning: o, transientData: w })),
+    recordUpdate: (i) => S((o) => o.recordUpdate(i)),
+    refreshResource: async (i) => await E(
+      async (o) => await o.refreshResource(i)
+    ),
+    // Methods: Modifying the collection
+    deleteResource: async (i) => await E(
+      async (o) => await o.deleteResource(i)
+    ),
+    saveResource: async (i) => await E(async (o) => await o.saveResource(i)),
+    saveResources: async (i) => await E(async (o) => await o.saveResources(i)),
+    // Methods: Transient data
+    clearTransientData: () => S((i) => i.clearTransientData()),
+    setInvalidResourceIds: (i) => S((o) => o.setInvalidResourceIds(i)),
+    setTransientDataForResources: (i) => S(
+      (o) => o.setTransientDataForResources(i)
+    ),
+    // Methods: Selection and detail selection
+    clearSelection: () => S((i) => i.clearSelection()),
+    deselectResources: (i) => S((o) => o.deselectResources(i)),
+    selectResources: (i, o) => S(
+      (w) => w.selectResources(i, o)
+    ),
+    // Methods: Managing the detail view
+    hideDetail: () => S((i) => i.hideDetail()),
+    // Methods: Editors
+    deregisterEditor: (i) => S((o) => o.deregisterEditor(i)),
+    registerEditor: (i) => S((o) => o.registerEditor(i)),
+    // Methods: List navigators
+    deregisterListNavigator: (i) => S((o) => o.deregisterListNavigator(i)),
+    registerListNavigator: (i) => S((o) => o.registerListNavigator(i)),
+    // Callbacks
+    onItemsStoreReady: Ee
+  };
+}, Qe = () => {
+  ie.clearAllStores();
+};
+function ae(f, s) {
+  return a.get(f, (s == null ? void 0 : s.idProperty) || "_id");
+}
+const Ue = {
+  idProperty: "_id"
+}, Z = {
+  resource: null,
+  status: "NotLoaded"
+}, xe = (f, s) => {
+  s = a.merge({}, Ue, s);
+  const R = ye(f, {
+    state: () => ({
+      idProperty: s.idProperty,
+      resourceId: s.resourceId || null,
+      resourceUrl: s.resourceUrl || null,
+      referencePathsToExpand: s.referencePathsToExpand || null,
+      ...Z
+    }),
+    getters: {
+      currentResourceUrl: (e) => e.resourceUrl || (s.restCollectionUrl && e.resourceId ? `${s.restCollectionUrl}/${e.resourceId}` : null) || s.restCollectionUrl || null,
+      /** Get the REST query parameters that can be determined from the options.  */
+      fixedQueryParams: (e) => {
+        const r = {};
+        return e.referencePathsToExpand && (r.r = V(e.referencePathsToExpand)), r;
+      }
+    },
+    actions: {
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // Actions: Configuration
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      /**
+       * Reset the store to its initial state.
+       *
+       * Configuration is retained, but REST resource content and contextual state are reset.
+       */
+      reset() {
+        for (const e in Z)
+          this[e] = Z[e];
+      },
+      async setResourceId(e) {
+        const r = this.currentResourceUrl;
+        this.resourceId = e, !a.isEqual(this.currentResourceUrl, r) && this.status != "NotLoaded" && await this.loadResource();
+      },
+      async setResourceUrl(e) {
+        const r = this.currentResourceUrl;
+        this.resourceUrl = e, !a.isEqual(this.currentResourceUrl, r) && this.status != "NotLoaded" && await this.loadResource();
+      },
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // Actions: Loading and unloading the collection
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      /**
+       * Clear the resource.
+       *
+       * Configuration and contextual state are retained, but REST collection contents are reset.
+       */
+      clear() {
+        for (const e in Z)
+          this[e] = Z[e];
+      },
+      /**
+       * Load the resource, if it has not been loaded.
+       *
+       * The resource will be loaded if its current status is not Loaded, Loading, or Failed.
+       */
+      async ensureResourceLoaded() {
+        ["Loaded", "Loading", "Failed"].includes(this.status) || await this.loadResource();
+      },
+      /**
+       * Load the resource.
+       *
+       * @return A promise that resolves when the resource has been loaded.
+       */
+      async loadResource() {
+        this.reset();
+        const e = X();
+        if (this._loadId = e, this.currentResourceUrl) {
+          this.status = "Loading";
+          const r = this.fixedQueryParams, t = a.cloneDeep(r), l = a.map(
+            t,
+            (c, d) => c != null ? `${encodeURIComponent(d)}=${encodeURIComponent(c)}` : null
+          ).filter((c) => c != null).join("&"), u = a.isEmpty(l) ? this.currentResourceUrl : `${this.currentResourceUrl}?${l}`;
+          try {
+            const c = await P.get(u), d = this.fixedQueryParams;
+            e != this._loadId || !a.isEqual(r, d) ? console.log(`Discarding resource fetched by obsolete query from ${u}.`) : (this.resource = me.decode(a.get(c, "data", {})), this.status = "Loaded");
+          } catch (c) {
+            console.log(`Error while loading resource (URL="${u}")`, c), this.reset(), this.status = "Failed";
+          }
+        } else
+          throw "Cannot load a resource because its URL, or its ID and collection URL, are unknown.";
+      },
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // Actions: Recording modifications to the collection
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      /**
+       * Verify that the resource does not exist in the remote collection.
+       *
+       * After checking the remote collection and verifying that the resource does not exist, this function calls
+       * {@link recordDeletion} to delete it from the local collection.
+       *
+       * @return true if the record does not exist in the remote collection, false if it does or if an error occurred.
+       */
+      async checkForDeletedResource() {
+        if (this.currentResourceUrl) {
+          let e;
+          try {
+            e = await P.get(this.currentResourceUrl);
+          } catch (r) {
+            P.isAxiosError(r) && (e = r.response);
+          }
+          return e && e.status == 404 ? (this.recordDeletion(), !0) : !1;
+        } else
+          throw "Cannot check for a deleted resource because its URL, or its ID and collection URL, are unknown.";
+      },
+      /**
+       * Record a deletion, removing the deleted resource from the local collection.
+       *
+       * This should be called after deleting the resource from the remote collection. It is called, for instance, by
+       * {@link deleteResource}; but it can also be called when the application is aware of a deletion from the remote
+       * collection made by other means.
+       */
+      recordDeletion() {
+        this.resource = null, this.status = "Loaded";
+      },
+      /**
+       * Record an insertion, adding the inserted resource to the local collection.
+       *
+       * This should be called after inserting a resource into the remote collection. It is called, for instance, by
+       * {@link saveResource}; but it can also be called when the application is aware of insertions into the remote
+       * collection made by other means.
+       *
+       * This should only be called if the inserted resource is a saved version of the resource tracked by this store.
+       * Otherwise the store's resource may not match its resourceId and resourceUrl properties when the function
+       * returns.
+       *
+       * It is important that the resources to be added to the local collection have the same object-graph
+       * characteristics as other resources in the local collection. (These characteristics include property inclusions
+       * and exclusions, as well as reference expansions.) To ensure this, you may call {@refreshResource} to fetch the
+       * resource using the collection's settings.
+       *
+       * @param resource The resource that has been inserted.
+       */
+      recordInsertion(e) {
+        this.resourceId = ae(e, this) || null, this.status == "Loaded" && (this.resource = Object.freeze(e));
+      },
+      /**
+       * Record an update, making the same changes in the local resource.
+       *
+       * This should be called after updating a remote resource. It is called, for instance, by {@link saveResource} and
+       * {@link refreshResource}; but it can also be called when the application is aware of updates in the remote
+       * collection made by other means.
+       *
+       * This should only be called if the inserted resource is a saved version of the resource tracked by this store.
+       * Otherwise the store's resource may not match its resourceId and resourceUrl properties when the function
+       * returns.
+       *
+       * It is important that the resource have the same object-graph characteristics as other resources in the local
+       * collection. (These characteristics include property inclusions and exclusions, as well as reference
+       * expansions.) To ensure this, you may instead call {@refreshResource} to fetch the  resource using the
+       * collection's settings; this will in turn call {@link recordUpdate}.
+       *
+       * @param resource The resource that has been updated.
+       */
+      recordUpdate(e) {
+        this.resourceId = ae(e, this) || null, this.status == "Loaded" && (this.resource = Object.freeze(e));
+      },
+      async refreshResource() {
+        return await this.loadResource(), this.resource;
+      },
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // Actions: Modifying the resource
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      /**
+       * Delete the resource.
+       *
+       * A delete request is sent to the REST API. If it succeeds, the resource is removed from the local store.
+       */
+      async deleteResource() {
+        if (this.currentResourceUrl)
+          (await P.delete(this.currentResourceUrl)).status == 200 && this.recordDeletion();
+        else
+          throw "Cannot delete a resource because its URL, or its ID and collection URL, are unknown.";
+      },
+      /**
+       * Write a new or updated resource to the remote resource, then mirror the change locally.
+       *
+       * After writing changes, {@link refreshResource} is called to ensure that the local resource (which is also the
+       * return value) has the same object-graph characteristics as the rest of the local collection.
+       *
+       * @param resource The new or updated resource. If it has an ID, an update will be attempted; otherwise it will be
+       *   created.
+       * @returns The refreshed local resource after the change has been persisted to the remote collection, or null if
+       *   the operation failed.
+       */
+      async saveResource(e) {
+        const r = ae(e, this), t = r == null;
+        if (!r)
+          throw "The REST resource store cannot create new resources on the server.";
+        if (!this.currentResourceUrl)
+          throw "Cannot save a resource because its URL, or its ID and collection URL, are unknown.";
+        const l = await P({
+          method: t ? "post" : "put",
+          url: this.currentResourceUrl,
+          data: e
+        });
+        if (l.status == 200) {
+          const u = l.data, c = await this.refreshResource();
+          return t && this.recordInsertion(c || u), c || Object.freeze(u);
+        }
+        return null;
+      },
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // Actions: Custom API endpoints
+      // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      async makeCustomApiRequest(e) {
+        const { method: r, subpath: t, url: l, data: u } = e;
+        let c = l;
+        if (!c)
+          if (this.currentResourceUrl)
+            c = `${this.currentResourceUrl}/${t}`;
+          else
+            throw "Cannot make a custom API request for a resource because its URL, or its ID and collection URL, are unknown.";
+        const d = await P({
+          method: r || "get",
+          url: c,
+          data: u
+        });
+        return d.status >= 200 && d.status < 300 ? d.data : null;
+      }
+    }
+  });
+  return (() => {
+    const e = (r, t) => {
+      const l = R(r, t);
+      return ne.registerStore(l.$id, l), l;
+    };
+    return e.$id = R.$id, e;
+  })();
+}, ne = new Ie(), Me = (f = {}) => {
+  const {
+    resourceClientId: s,
+    draftBatchId: R,
+    enabled: L,
+    resourceType: e,
+    options: r
+  } = f, t = I(void 0), l = I(s), u = I(R), c = I(L ?? !0), d = I([te(e)]), y = I(r), U = m(() => u.value), T = I(c.value), b = I(X()), q = m(
+    () => u.value == null && l.value != null && ne.getStore(l.value) != null
+  ), A = I(q.value), z = m(() => S("status", "Uninitialized"));
+  function B(n) {
+    if (t.value)
+      return n(t.value);
+  }
+  async function g(n) {
+    if (t.value)
+      return await n(t.value);
+  }
+  function S(n, h) {
+    if (t.value)
+      return t.value[n];
+    if (h !== void 0)
+      return h;
+    throw "Attempted to use a REST resource store that has not been created, with no default value.";
+  }
+  const E = (n = {}) => {
+    const {
+      resourceClientId: h,
+      draftBatchId: F,
+      enabled: N,
+      resourceType: G,
+      options: j
+    } = n;
+    l.value = h, u.value = F, c.value = N ?? !0, d.value = [te(G)], j != null && (y.value = j), b.value = X(), $(c.value);
+  }, $ = async (n) => {
+    n != T.value && (T.value = n, n && x());
+  }, D = m(
+    () => d.value[0].value || void 0
+  ), W = function(n) {
+    const h = a.get(n, "referencePathsToExpand"), F = D.value ? a.isFunction(h) ? h(D.value) : h || [] : [];
+    return {
+      ...a.cloneDeep(n || {}),
+      referencePathsToExpand: F
+    };
+  }, H = m(() => W(y.value)), J = m(() => {
+    if (!D.value)
+      return null;
+    if (!A.value)
+      return !D.value || !D.value.collectionName ? null : U.value ? `${ee.config.apiBaseUrl}/draft-batches/${U.value}/${D.value.collectionName}` : `${ee.config.apiBaseUrl}/${D.value.collectionName}`;
+  }), K = m(() => {
+    if (D.value && J.value)
+      return a.mergeWith(
+        a.cloneDeep(Ue),
+        H.value,
+        {
+          idProperty: D.value.idProperty,
+          restCollectionUrl: J.value
+        },
+        (n, h) => {
+          if (a.isArray(h) && h.length == 0 && (n == null || a.isArray(n)))
+            return h;
+        }
+      );
+  }), p = I(0), k = m(
+    () => {
+      var n;
+      return p.value, l.value || D.value && ((n = D.value) == null ? void 0 : n.collectionName) && (U.value ? `draftBatches/${U.value}/${D.value.collectionName}/${b.value}` : `${D.value.collectionName}/${b.value}`) || null;
+    }
+  ), x = () => {
+    if (T.value) {
+      let n = !1;
+      return D.value && k.value && (t.value = ne.getStore(k.value), t.value ? n = !1 : K.value && (A.value = !1, t.value = xe(k.value, K.value)(), n = !0)), n;
+    } else
+      return !1;
+  }, M = () => {
+    k.value && l.value == k.value ? (t.value = void 0, x()) : (t.value = void 0, p.value = p.value + 1, x());
+  };
+  return C(U, (n, h) => {
+    a.isEqual(n, h) || M();
+  }), C(T, (n, h) => {
+    n != h && (n ? x() : t.value = void 0);
+  }), C(D, (n, h) => {
+    n && !h ? x() : !n && h || a.isEqual(n, h) || M();
+  }), C(K, (n, h) => {
+    a.isEqual(n, h) || M();
+  }), C(q, () => {
+    q.value || (A.value = !1);
+  }), C(k, () => x()), C(J, (n, h) => {
+    a.isEqual(n, h) || M();
+  }), x(), {
+    // Configuration
+    resourceClientId: k,
+    draftBatchId: U,
+    enabled: T,
+    resourceType: D,
+    // Status
+    status: z,
+    // Resources loaded from the REST API
+    resource: m(() => z.value != "Uninitialized" ? (g((n) => n.ensureResourceLoaded()), S("resource", [])) : []),
+    resourceId: m(() => S("resourceId", null)),
+    resourceUrl: m(() => S("resourceUrl", null)),
+    // Methods: Configuration
+    reconfigureClient: E,
+    setEnabled: $,
+    setResourceId: async (n) => await g(async (h) => await h.setResourceId(n)),
+    setResourceUrl: async (n) => await g(async (h) => await h.setResourceUrl(n)),
+    // Methods: Status
+    ensureStore: x,
+    // Methods: Resource management
+    clear: () => B((n) => n.clear()),
+    ensureResourceLoaded: async () => await g(async (n) => n.ensureResourceLoaded()),
+    loadResource: async () => await g(async (n) => await n.loadResource()),
+    // Methods: Recording changes to the resource
+    checkForDeletedResource: async () => await g(async (n) => await n.checkForDeletedResource()) == !0,
+    recordDeletion: () => g((n) => n.recordDeletion()),
+    recordInsertion: (n) => g((h) => h.recordInsertion(n)),
+    recordUpdate: (n) => g((h) => h.recordUpdate(n)),
+    refreshResource: async () => await g(async (n) => await n.refreshResource()),
+    // Methods: Modifying the resource
+    deleteResource: async () => await g(async (n) => await n.deleteResource()),
+    saveResource: async (n) => await g(async (h) => await h.saveResource(n)),
+    // Methods: Custom API endpoints
+    makeCustomApiRequest: async (n) => await g(
+      async (h) => await h.makeCustomApiRequest(n)
+    )
+  };
+}, ee = {
+  config: { ...pe }
+};
+function je(f) {
+  ee.config = a.merge({}, pe, f);
+}
+export {
+  ke as ApiClientError,
+  Qe as clearAllRestCollections,
+  je as initRestClient,
+  ee as restClient,
+  Be as useRestCollection,
+  Me as useRestResource
+};