@logimaxx/kviews.js 1.2.3

package/dist/index.js

@@ -0,0 +1,4039 @@
+// src/utils.js
+function dbg() {
+  if (typeof kviewsLogLevel !== "undefined" && kviewsLogLevel >= 3) {
+    console.trace(...arguments);
+  }
+}
+function log() {
+  if (typeof kviewsLogLevel !== "undefined" && kviewsLogLevel >= 2) {
+    console.log(...arguments);
+  }
+}
+function error() {
+  if (typeof kviewsLogLevel !== "undefined" && kviewsLogLevel >= 1) {
+    console.error(...arguments);
+  }
+}
+function trace() {
+  if (typeof kviewsLogLevel !== "undefined" && kviewsLogLevel >= 4) {
+    console.trace(...arguments);
+  }
+}
+function uid() {
+  return "uid_" + Math.random().toString(36).substr(2, 9);
+}
+function parseOptions(options) {
+  if (typeof options === "undefined") {
+    return {};
+  }
+  if (options.constructor === Object) {
+    return options;
+  }
+  throw new Error("Invalid options", options);
+}
+function deepmerge(target, source, optionsArgument) {
+  function defaultArrayMerge(target2, source2, optionsArgument2) {
+    let destination = target2.slice();
+    source2.forEach(function(e, i) {
+      if (typeof destination[i] === "undefined") {
+        destination[i] = cloneIfNecessary(e, optionsArgument2);
+      } else if (isMergeableObject(e)) {
+        destination[i] = deepmerge(target2[i], e, optionsArgument2);
+      } else if (target2.indexOf(e) === -1) {
+        destination.push(cloneIfNecessary(e, optionsArgument2));
+      }
+    });
+    return destination;
+  }
+  function isMergeableObject(val) {
+    var nonNullObject = val && typeof val === "object";
+    return nonNullObject && Object.prototype.toString.call(val) !== "[object RegExp]" && Object.prototype.toString.call(val) !== "[object Date]";
+  }
+  function emptyTarget(val) {
+    return Array.isArray(val) ? [] : {};
+  }
+  function cloneIfNecessary(value, optionsArgument2) {
+    let clone = optionsArgument2 && optionsArgument2.clone === true;
+    return clone && isMergeableObject(value) ? deepmerge(emptyTarget(value), value, optionsArgument2) : value;
+  }
+  function mergeObject(target2, source2, optionsArgument2) {
+    let destination = {};
+    if (isMergeableObject(target2)) {
+      Object.keys(target2).forEach(function(key) {
+        destination[key] = cloneIfNecessary(target2[key], optionsArgument2);
+      });
+    }
+    Object.keys(source2).forEach(function(key) {
+      if (!isMergeableObject(source2[key]) || !target2[key]) {
+        destination[key] = cloneIfNecessary(source2[key], optionsArgument2);
+      } else {
+        destination[key] = deepmerge(target2[key], source2[key], optionsArgument2);
+      }
+    });
+    return destination;
+  }
+  let array = Array.isArray(source);
+  let options = optionsArgument || { arrayMerge: defaultArrayMerge };
+  let arrayMerge = options.arrayMerge || defaultArrayMerge;
+  if (array) {
+    return Array.isArray(target) ? arrayMerge(target, source, optionsArgument) : cloneIfNecessary(source, optionsArgument);
+  } else {
+    return mergeObject(target, source, optionsArgument);
+  }
+}
+deepmerge.all = function deepmergeAll(array, optionsArgument) {
+  if (!Array.isArray(array) || array.length < 2) {
+    throw new Error("first argument should be an array with at least two elements");
+  }
+  return array.reduce(function(prev, next) {
+    return deepmerge(prev, next, optionsArgument);
+  });
+};
+function getBoundObjects(el) {
+  let db = {};
+  if (!el || $(el).length === 0) {
+    return db;
+  }
+  let boundData = $(el).data();
+  for (let key in boundData) {
+    if (typeof boundData[key] === "object" && key !== "instance") {
+      db[key] = boundData[key];
+    }
+  }
+  return db;
+}
+function template(text) {
+  if (typeof Handlebars !== "undefined") {
+    return Handlebars.compile(text);
+  }
+  throw new Error("Handlebars is required for template compilation");
+}
+function createOverlay(instance) {
+  return $(document.createElement("div")).text("Se incarca 123").addClass("komponent-overlay").data("asd", instance).attr(
+    "style",
+    "background: linear-gradient(135deg,rgb(191, 225, 205),rgb(236, 234, 232) 70%, #fca); text-align: center; position:absolute; z-index:100000;"
+  );
+}
+
+// src/apiBase.js
+var apiBaseConfig = {
+  baseUrl: null,
+  basePath: null,
+  defaultHeaders: {}
+};
+function resolveRequestUrl(url) {
+  if (url == null || url === "") {
+    return url;
+  }
+  const s = typeof url === "string" ? url : String(url);
+  if (/^https?:\/\//i.test(s) || s.startsWith("//")) {
+    return s;
+  }
+  const base = apiBaseConfig.baseUrl || apiBaseConfig.basePath || "";
+  if (!base) {
+    return s;
+  }
+  const baseNorm = base.replace(/\/+$/, "");
+  const pathNorm = s.replace(/^\/+/, "");
+  if (!pathNorm) {
+    return baseNorm + "/";
+  }
+  return baseNorm + "/" + pathNorm;
+}
+
+// src/errors.js
+var KViewsError = class extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "KViewsError";
+    this.options = options.options || {};
+    this.context = options.context || null;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var KViewsHttpError = class extends KViewsError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "KViewsHttpError";
+    this.status = options.status || 0;
+    this.statusText = options.statusText || "error";
+    this.responseText = options.responseText || null;
+    this.responseJSON = options.responseJSON || null;
+    this.jqXHR = options.jqXHR || null;
+    this.textStatus = options.textStatus || "error";
+    this.errorThrown = options.errorThrown || null;
+  }
+};
+var KViewsParseError = class extends KViewsError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "KViewsParseError";
+    this.rawData = options.rawData || null;
+    this.parseStep = options.parseStep || null;
+  }
+};
+var KViewsUrlError = class extends KViewsError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "KViewsUrlError";
+    this.url = options.url || null;
+  }
+};
+var KViewsNetworkError = class extends KViewsError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "KViewsNetworkError";
+    this.originalError = options.originalError || null;
+    this.url = options.url || null;
+  }
+};
+
+// src/URL.js
+var URL = class {
+  constructor(url) {
+    if (!url) {
+      throw new KViewsUrlError("URL is not provided", { url });
+    }
+    if (typeof url === "object" && url.hasOwnProperty("protocol")) {
+      Object.assign(this, url);
+      if (this.parameters && !this.parameters.toString) {
+        this._addParametersToString();
+      }
+      return;
+    }
+    if (url.constructor !== String) {
+      dbg("URL is not a string", url);
+      throw new KViewsUrlError("URL is not a string: " + url.toString(), { url });
+    }
+    const isAbsolute = /^[a-z]+:\/\//i.test(url);
+    if (isAbsolute && typeof window !== "undefined" && window.URL) {
+      try {
+        const standardUrl = new window.URL(url);
+        this.protocol = standardUrl.protocol ? standardUrl.protocol.replace(":", "") : null;
+        this.fqdn = standardUrl.hostname || null;
+        this.port = standardUrl.port || null;
+        this.path = standardUrl.pathname || null;
+        this.fragment = standardUrl.hash ? standardUrl.hash.replace("#", "") : null;
+        this.parameters = {};
+        if (standardUrl.search) {
+          const params = new URLSearchParams(standardUrl.search);
+          params.forEach((value, key) => {
+            this.parameters[key] = value;
+          });
+        }
+      } catch (e) {
+        this._parseRelativeUrl(url);
+      }
+    } else {
+      this._parseRelativeUrl(url);
+    }
+    this._addParametersToString();
+  }
+  /**
+   * Parse relative URL using regex fallback
+   * @private
+   */
+  _parseRelativeUrl(url) {
+    let regExp = /^((?:([a-z]+):)([\/]{2,3})([\w\.\-\_]+)(?::(\d+))?)?(?:(\/?[^?#]*))?(?:\?([^#]*))?(?:#(.*))?$/i;
+    let parts = regExp.exec(url);
+    this.protocol = null;
+    this.fqdn = null;
+    this.port = null;
+    this.path = null;
+    this.parameters = {};
+    this.fragment = null;
+    if (typeof parts[2] !== "undefined") {
+      this.protocol = parts[2];
+    }
+    if (typeof parts[4] !== "undefined") {
+      this.fqdn = parts[4];
+    }
+    if (typeof parts[5] !== "undefined") {
+      this.port = parts[5];
+    }
+    if (typeof parts[6] !== "undefined") {
+      this.path = parts[6];
+    }
+    if (typeof parts[7] !== "undefined") {
+      try {
+        const params = new URLSearchParams(parts[7]);
+        params.forEach((value, key) => {
+          this.parameters[key] = value;
+        });
+      } catch (e) {
+        let tmp = parts[7].split("&");
+        tmp.forEach((item) => {
+          if (!item || item === "") {
+            return;
+          }
+          let eqPos = item.indexOf("=");
+          if (eqPos === -1) {
+            this.parameters[item] = "";
+          } else {
+            this.parameters[item.substr(0, eqPos)] = decodeURIComponent(item.substr(eqPos + 1));
+          }
+        });
+      }
+    }
+    if (typeof parts[8] !== "undefined") {
+      this.fragment = parts[8];
+    }
+  }
+  /**
+   * Add toString method to parameters object
+   * @private
+   */
+  _addParametersToString() {
+    if (!this.parameters.toString || this.parameters.toString === Object.prototype.toString) {
+      const self = this;
+      this.parameters.toString = function() {
+        if (typeof URLSearchParams !== "undefined") {
+          try {
+            const params = new URLSearchParams();
+            for (let para in this) {
+              if (this.hasOwnProperty(para) && para !== "toString") {
+                params.append(para, String(this[para]));
+              }
+            }
+            return params.toString();
+          } catch (e) {
+          }
+        }
+        let paras = [];
+        for (let para in this) {
+          if (this.hasOwnProperty(para) && para !== "toString") {
+            const value = String(this[para]);
+            paras.push(encodeURIComponent(para) + "=" + encodeURIComponent(value));
+          }
+        }
+        return paras.join("&");
+      };
+    }
+  }
+  toString() {
+    let str = "";
+    if (this.protocol && this.fqdn) {
+      if (typeof window !== "undefined" && window.URL) {
+        try {
+          const baseUrl = this.protocol + "://" + this.fqdn + (this.port ? ":" + this.port : "");
+          const url = new window.URL(this.path || "/", baseUrl);
+          if (this.parameters && Object.keys(this.parameters).length > 0) {
+            Object.getOwnPropertyNames(this.parameters).forEach((key) => {
+              if (key !== "toString") {
+                url.searchParams.set(key, this.parameters[key]);
+              }
+            });
+          }
+          if (this.fragment) {
+            url.hash = this.fragment;
+          }
+          return url.toString();
+        } catch (e) {
+        }
+      }
+      str += this.protocol + "://" + this.fqdn;
+      if (this.port) {
+        str += ":" + this.port;
+      }
+    }
+    if (this.path) {
+      str += this.path;
+    }
+    if (this.parameters && Object.keys(this.parameters).length > 0) {
+      str += "?" + this.parameters.toString();
+    }
+    if (this.fragment) {
+      str += "#" + this.fragment;
+    }
+    return str;
+  }
+};
+function createURL(url) {
+  return new URL(url);
+}
+
+// src/Storage.js
+var Storage = class {
+  constructor(options = {}) {
+    let defaultOptions = {
+      url: null,
+      method: "GET"
+    };
+    options = parseOptions(options);
+    Object.assign(defaultOptions, options);
+    this.defaultOptions = defaultOptions;
+  }
+  /**
+   * Base sync method - uses Fetch API
+   */
+  sync(options) {
+    if (options.url && typeof options.url === "object" && options.url.toString) {
+      options.url = options.url.toString();
+    }
+    options.url = resolveRequestUrl(options.url);
+    options = Object.assign(
+      Object.assign({}, this.defaultOptions),
+      parseOptions(options)
+    );
+    const globalHeaders = apiBaseConfig.defaultHeaders && typeof apiBaseConfig.defaultHeaders === "object" ? apiBaseConfig.defaultHeaders : {};
+    const defaultHeaders = this.defaultOptions.headers && typeof this.defaultOptions.headers === "object" ? this.defaultOptions.headers : {};
+    const requestHeaders = options.headers && typeof options.headers === "object" ? options.headers : {};
+    options.headers = Object.assign({}, globalHeaders, defaultHeaders, requestHeaders);
+    if (!options.hasOwnProperty("url")) {
+      throw new Error("No URL provided");
+    }
+    if (options.url && typeof options.url === "object" && options.url.toString) {
+      options.url = options.url.toString();
+    }
+    const fetchOptions = {
+      method: options.method || "GET",
+      headers: {}
+    };
+    if (options.headers) {
+      Object.assign(fetchOptions.headers, options.headers);
+    }
+    if (options.contentType) {
+      fetchOptions.headers["Content-Type"] = options.contentType;
+    }
+    if (options.data && ["POST", "PUT", "PATCH"].includes(fetchOptions.method)) {
+      fetchOptions.body = options.data;
+    }
+    return fetch(options.url, fetchOptions).catch((fetchError) => {
+      throw new KViewsNetworkError(
+        fetchError instanceof Error ? fetchError.message : String(fetchError),
+        {
+          originalError: fetchError instanceof Error ? fetchError : new Error(String(fetchError)),
+          url: options.url,
+          options
+        }
+      );
+    }).then(async (response) => {
+      const jqXHR = {
+        status: response.status,
+        statusText: response.statusText,
+        responseText: null,
+        responseJSON: null,
+        getAllResponseHeaders: () => {
+          const headers = {};
+          response.headers.forEach((value, key) => {
+            headers[key] = value;
+          });
+          return Object.entries(headers).map(([key, value]) => `${key}: ${value}`).join("\r\n");
+        },
+        getResponseHeader: (name) => {
+          return response.headers.get(name);
+        }
+      };
+      const text = await response.text();
+      let data = text;
+      try {
+        data = JSON.parse(text);
+      } catch (e) {
+      }
+      jqXHR.responseText = text;
+      jqXHR.responseJSON = typeof data === "object" ? data : null;
+      if (!response.ok) {
+        const error2 = new KViewsHttpError(
+          `HTTP ${response.status}: ${response.statusText}`,
+          {
+            status: response.status,
+            statusText: response.statusText,
+            responseText: text,
+            responseJSON: typeof data === "object" ? data : null,
+            jqXHR,
+            options,
+            errorThrown: new Error(`HTTP ${response.status}: ${response.statusText}`)
+          }
+        );
+        error2.textStatus = "error";
+        throw error2;
+      }
+      return {
+        data,
+        textStatus: "success",
+        jqXHR
+      };
+    }).catch((error2) => {
+      if (error2 instanceof KViewsHttpError || error2 instanceof KViewsNetworkError) {
+        throw error2;
+      }
+      const jqXHR = {
+        status: 0,
+        statusText: "error",
+        responseText: null,
+        responseJSON: null,
+        getAllResponseHeaders: () => "",
+        getResponseHeader: () => null
+      };
+      const httpError = new KViewsHttpError(
+        error2 instanceof Error ? error2.message : String(error2),
+        {
+          status: 0,
+          statusText: "error",
+          responseText: null,
+          responseJSON: null,
+          jqXHR,
+          options,
+          errorThrown: error2 instanceof Error ? error2 : new Error(String(error2))
+        }
+      );
+      httpError.textStatus = "error";
+      throw httpError;
+    });
+  }
+  /**
+   * Create (POST) operation
+   */
+  create(ctx, url, opts, data) {
+    let options = {
+      context: ctx,
+      url,
+      method: "POST",
+      data
+    };
+    Object.assign(options, opts);
+    return this.sync(options);
+  }
+  /**
+   * Read (GET) operation
+   */
+  read(ctx, url, opts) {
+    let options = {
+      context: ctx,
+      url,
+      method: "GET"
+    };
+    Object.assign(options, opts);
+    return this.sync(options);
+  }
+  /**
+   * Delete (DELETE) operation
+   */
+  delete(ctx, url, opts) {
+    let options = {
+      context: ctx,
+      url,
+      method: "DELETE"
+    };
+    Object.assign(options, opts);
+    return this.sync(options);
+  }
+  /**
+   * Update (PATCH) operation
+   */
+  update(ctx, url, opts, data) {
+    let options = {
+      context: ctx,
+      url,
+      method: "PATCH",
+      contentType: "application/vnd.api+json",
+      data
+    };
+    Object.assign(options, opts);
+    return this.sync(options);
+  }
+};
+
+// src/dataParser.js
+function getIncludedResources(doc) {
+  if (!doc || typeof doc !== "object") {
+    return [];
+  }
+  const includedData = doc.hasOwnProperty("included") ? doc.included : doc.hasOwnProperty("includes") ? doc.includes : null;
+  if (!includedData) {
+    return [];
+  }
+  if (!Array.isArray(includedData)) {
+    return [];
+  }
+  return includedData;
+}
+function buildResourceIndex(doc) {
+  const index = /* @__PURE__ */ new Map();
+  if (!doc || typeof doc !== "object") {
+    return index;
+  }
+  function indexResource(resource) {
+    if (!resource || typeof resource !== "object") {
+      return;
+    }
+    if (!resource.type || !resource.id) {
+      return;
+    }
+    const key = `${resource.type}/${resource.id}`;
+    if (!index.has(key)) {
+      index.set(key, resource);
+    }
+  }
+  if (doc.data) {
+    if (Array.isArray(doc.data)) {
+      doc.data.forEach(indexResource);
+    } else if (typeof doc.data === "object") {
+      indexResource(doc.data);
+    }
+  }
+  const included = getIncludedResources(doc);
+  included.forEach(indexResource);
+  return index;
+}
+function getResourceFromIndex(typeOrRef, id, resourceIndex) {
+  let type, resourceId;
+  if (typeof typeOrRef === "object" && typeOrRef !== null) {
+    type = typeOrRef.type;
+    resourceId = typeOrRef.id;
+  } else {
+    type = typeOrRef;
+    resourceId = id;
+  }
+  if (!type || !resourceId) {
+    return null;
+  }
+  const key = `${type}/${resourceId}`;
+  return resourceIndex.get(key) || null;
+}
+function hydrateResource(resource, resourceIndex, visited = /* @__PURE__ */ new Set()) {
+  if (!resource || typeof resource !== "object") {
+    return resource;
+  }
+  if (!resource.relationships) {
+    return resource;
+  }
+  const resourceKey = resource.type && resource.id ? `${resource.type}/${resource.id}` : null;
+  if (resourceKey && visited.has(resourceKey)) {
+    return resource;
+  }
+  if (resourceKey) {
+    visited.add(resourceKey);
+  }
+  Object.keys(resource.relationships).forEach((relName) => {
+    const rel = resource.relationships[relName];
+    if (rel === null) {
+      return;
+    }
+    if (rel.data !== void 0) {
+      if (rel.data === null) {
+        resource.relationships[relName] = null;
+      } else if (Array.isArray(rel.data)) {
+        resource.relationships[relName] = rel.data.map((ref) => {
+          const hydrated = getResourceFromIndex(ref, null, resourceIndex);
+          if (hydrated) {
+            return hydrateResource(
+              hydrated,
+              // Use same object instance from index
+              resourceIndex,
+              new Set(visited)
+              // New visited set for each branch
+            );
+          }
+          return ref;
+        }).filter((r) => r !== null);
+      } else if (typeof rel.data === "object" && rel.data.type && rel.data.id) {
+        const hydrated = getResourceFromIndex(rel.data, null, resourceIndex);
+        if (hydrated) {
+          resource.relationships[relName] = hydrateResource(
+            hydrated,
+            // Use same object instance from index
+            resourceIndex,
+            new Set(visited)
+            // New visited set for each branch
+          );
+        } else {
+          resource.relationships[relName] = rel.data;
+        }
+      } else {
+        resource.relationships[relName] = rel.data;
+      }
+    } else {
+      resource.relationships[relName] = rel;
+    }
+  });
+  return resource;
+}
+function hydrateDocumentData(doc) {
+  if (!doc || typeof doc !== "object") {
+    throw new KViewsParseError("Invalid document: must be an object");
+  }
+  const resourceIndex = buildResourceIndex(doc);
+  if (!doc.data) {
+    return null;
+  }
+  const data = doc.data;
+  if (Array.isArray(data)) {
+    data.forEach((resource) => hydrateResource(resource, resourceIndex));
+    return data;
+  } else if (typeof data === "object") {
+    return hydrateResource(data, resourceIndex);
+  }
+  return data;
+}
+function parseItemData(data, options = {}) {
+  let hydratedResource;
+  let doc = data;
+  if (data && typeof data === "object" && data.type && data.id && !data.data) {
+    hydratedResource = data;
+  } else if (data && data.data) {
+    doc = data;
+    hydratedResource = hydrateDocumentData(doc);
+  } else {
+    hydratedResource = data;
+  }
+  if (!hydratedResource || typeof hydratedResource !== "object") {
+    throw new KViewsParseError("Invalid item data: must be an object");
+  }
+  if (doc && doc.links && doc.links.self && !hydratedResource.url) {
+    hydratedResource.url = createURL(doc.links.self);
+  }
+  return hydratedResource;
+}
+function parseCollectionData(doc) {
+  if (!doc || typeof doc !== "object") {
+    return [];
+  }
+  const hydratedData = hydrateDocumentData(doc);
+  if (!hydratedData) {
+    return [];
+  }
+  if (!Array.isArray(hydratedData)) {
+    return [hydratedData];
+  }
+  return hydratedData;
+}
+function parseDataForInsertOrUpdate(itemData) {
+  if (itemData === null) {
+    return null;
+  }
+  if (typeof itemData !== "object") {
+    throw new Error("Invalid item data: " + itemData);
+  }
+  if (itemData.constructor === Array || itemData.hasOwnProperty("items") && itemData.hasOwnProperty("length")) {
+    let resource2 = [];
+    itemData.forEach(function(item) {
+      resource2.push(parseDataForInsertOrUpdate(item));
+    });
+    return resource2;
+  }
+  if (itemData.constructor !== Object) {
+    throw new Error("Invalid case");
+  }
+  let resource = {};
+  if (!itemData.hasOwnProperty("attributes")) {
+    let tmp = { attributes: {} };
+    if (itemData.hasOwnProperty("type")) {
+      tmp.type = itemData.type;
+    }
+    Object.assign(tmp.attributes, itemData);
+    itemData = tmp;
+  }
+  Object.getOwnPropertyNames(itemData.attributes).forEach(function(attr) {
+    if (itemData.attributes[attr] && typeof itemData.attributes[attr] === "object") {
+      if (!resource.relationships) {
+        resource.relationships = {};
+      }
+      resource.relationships[attr] = {
+        data: parseDataForInsertOrUpdate(itemData.attributes[attr])
+      };
+      return;
+    }
+    if (!resource.attributes) {
+      resource.attributes = {};
+    }
+    resource.attributes[attr] = itemData.attributes[attr];
+  });
+  return resource;
+}
+
+// src/adapters/JsonApiAdapter.js
+var JsonApiAdapter = class {
+  /** @type {string} */
+  name = "jsonapi";
+  /**
+   * Whether a remote response represents a single resource (not a collection).
+   *
+   * @param {object} data - Raw HTTP response body
+   * @returns {boolean}
+   */
+  isSingleItemResponse(data) {
+    return !!(data && data.data && typeof data.data === "object" && !Array.isArray(data.data));
+  }
+  /**
+   * Extract pagination metadata from a remote document.
+   *
+   * @param {object} data - Raw HTTP response body
+   * @returns {{ totalRecords?: number, offset?: number }}
+   */
+  extractMetadata(data) {
+    const meta = {};
+    if (!data || !data.hasOwnProperty("meta") || typeof data.meta !== "object") {
+      return meta;
+    }
+    if (data.meta.hasOwnProperty("totalRecords")) {
+      meta.totalRecords = data.meta.totalRecords * 1;
+    }
+    if (data.meta.hasOwnProperty("offset")) {
+      meta.offset = data.meta.offset;
+    }
+    return meta;
+  }
+  /**
+   * Apply extracted metadata to a Collection instance.
+   *
+   * @param {object} collection - Collection instance
+   * @param {{ totalRecords?: number, offset?: number }} meta
+   */
+  applyMetadata(collection, meta) {
+    if (meta.totalRecords !== void 0) {
+      collection.total = meta.totalRecords;
+    }
+    if (meta.offset !== void 0) {
+      collection.offset = meta.offset;
+    }
+  }
+  /**
+   * Parse a single-item remote document into a canonical resource object.
+   *
+   * @param {object} data - Raw HTTP response body
+   * @param {object} [options]
+   * @returns {object} Hydrated resource ready for Item.loadFromData()
+   */
+  parseItemResponse(data, options = {}) {
+    this.validateItemRemoteDoc(data, options);
+    return parseItemData(data, options);
+  }
+  /**
+   * Validate that a remote document is suitable for a single Item load.
+   *
+   * @param {object} data - Raw HTTP response body
+   * @param {object} [options]
+   * @param {object} [options.collection] - Parent collection (for type inference)
+   */
+  validateItemRemoteDoc(data) {
+    if (data?.data?.constructor === Array) {
+      throw new Error("Invalid configuration: resource type is item but server response is collection");
+    }
+  }
+  /**
+   * Infer resource type from a single-item remote document.
+   *
+   * @param {object} data - Raw HTTP response body
+   * @returns {string|undefined}
+   */
+  inferItemType(data) {
+    return data?.data?.type;
+  }
+  /**
+   * Parse a collection remote document into canonical resource objects.
+   *
+   * @param {object} doc - Raw HTTP response body
+   * @returns {{ items: Array<object>, meta: object }}
+   */
+  parseCollectionResponse(doc) {
+    const items = parseCollectionData(doc);
+    const meta = this.extractMetadata(doc);
+    return { items, meta };
+  }
+  /**
+   * Apply list query parameters to a URL object before a collection fetch.
+   *
+   * @param {import('../URL.js').URL} url - Collection URL
+   * @param {{ type?: string, offset?: number, pageSize?: number }} params
+   */
+  applyListQuery(url, params) {
+    const { type, offset, pageSize } = params;
+    if (typeof offset !== "undefined" && offset !== null && type) {
+      url.parameters[`page[${type}][offset]`] = offset;
+    }
+    if (typeof pageSize !== "undefined" && pageSize !== null && type) {
+      url.parameters[`page[${type}][limit]`] = pageSize;
+    }
+  }
+  /**
+   * Serialize plain item data for a create (POST) request.
+   *
+   * @param {object|Array} itemData - Single item or array of items
+   * @param {{ type?: string }} [context]
+   * @returns {{ body: string, contentType: string, headers?: object }}
+   */
+  serializeForCreate(itemData, context = {}) {
+    const doc = { data: parseDataForInsertOrUpdate(itemData) };
+    if (context.type) {
+      doc.type = context.type;
+    }
+    return {
+      body: JSON.stringify(doc),
+      contentType: "application/vnd.api+json"
+    };
+  }
+  /**
+   * Serialize changed fields for an update (PATCH) request.
+   *
+   * @param {object} toUpdate - Resource patch with id, type, attributes, relationships
+   * @returns {{ body: string, contentType: string }}
+   */
+  serializeForUpdate(toUpdate) {
+    return {
+      body: JSON.stringify({ data: toUpdate }),
+      contentType: "application/vnd.api+json"
+    };
+  }
+  /**
+   * Serialize a runtime relationship value to JSON:API wire format.
+   *
+   * @param {object|Array|null} rel - Runtime relationship value
+   * @returns {object} JSON:API relationship: { data: ... }
+   */
+  serializeRelationship(rel) {
+    if (rel === null) {
+      return { data: null };
+    }
+    if (rel && typeof rel === "object" && !Array.isArray(rel)) {
+      if (rel.id) {
+        const result = { data: { id: rel.id } };
+        if (rel.type) {
+          result.data.type = rel.type;
+        }
+        return result;
+      }
+      if (rel.hasOwnProperty("toJSON")) {
+        const json = rel.toJSON();
+        const result = { data: { id: json.id } };
+        if (json.type) {
+          result.data.type = json.type;
+        }
+        return result;
+      }
+      return { data: null };
+    }
+    if (Array.isArray(rel)) {
+      return {
+        data: rel.map((item) => {
+          if (item && typeof item === "object") {
+            if (item.type && item.id) {
+              const result = { id: item.id };
+              if (item.type) {
+                result.type = item.type;
+              }
+              return result;
+            }
+            if (item.hasOwnProperty("toJSON")) {
+              const json = item.toJSON();
+              const result = { id: json.id };
+              if (json.type) {
+                result.type = json.type;
+              }
+              return result;
+            }
+          }
+          return item;
+        }).filter((item) => item && item.id)
+      };
+    }
+    return { data: null };
+  }
+};
+
+// src/adapters/plainUtils.js
+function getPath(obj, path) {
+  if (!obj || !path || typeof path !== "string") {
+    return void 0;
+  }
+  return path.split(".").reduce((current, key) => {
+    if (current == null || typeof current !== "object") {
+      return void 0;
+    }
+    return current[key];
+  }, obj);
+}
+function extractCollectionRows(doc, itemsPath) {
+  if (Array.isArray(doc)) {
+    return doc;
+  }
+  if (!doc || typeof doc !== "object") {
+    return [];
+  }
+  if (itemsPath) {
+    const rows = getPath(doc, itemsPath);
+    return Array.isArray(rows) ? rows : [];
+  }
+  if (Array.isArray(doc.data)) {
+    return doc.data;
+  }
+  if (Array.isArray(doc.items)) {
+    return doc.items;
+  }
+  if (Array.isArray(doc.results)) {
+    return doc.results;
+  }
+  return [];
+}
+function extractTotalRecords(doc, totalPath) {
+  if (!doc || typeof doc !== "object") {
+    return void 0;
+  }
+  if (totalPath) {
+    const value = getPath(doc, totalPath);
+    return value != null ? value * 1 : void 0;
+  }
+  for (const path of ["total", "count", "totalCount", "meta.totalRecords"]) {
+    const value = getPath(doc, path);
+    if (value != null) {
+      return value * 1;
+    }
+  }
+  return void 0;
+}
+function extractOffset(doc, offsetPath) {
+  if (!doc || typeof doc !== "object") {
+    return void 0;
+  }
+  if (offsetPath) {
+    const value = getPath(doc, offsetPath);
+    return value != null ? value : void 0;
+  }
+  for (const path of ["offset", "meta.offset"]) {
+    const value = getPath(doc, path);
+    if (value != null) {
+      return value;
+    }
+  }
+  return void 0;
+}
+
+// src/adapters/PlainRestAdapter.js
+var PlainRestAdapter = class {
+  /** @type {string} */
+  name = "plain";
+  /**
+   * @param {object} [opts]
+   * @param {string|null} [opts.itemsPath] - Dot path to item array (null = auto-detect)
+   * @param {string|null} [opts.itemPath] - Dot path to single item in a wrapper document
+   * @param {string|null} [opts.totalPath] - Dot path to total count (null = auto-detect)
+   * @param {string|null} [opts.offsetPath] - Dot path to offset (null = auto-detect)
+   * @param {string} [opts.idField] - Primary key field name
+   * @param {string|null} [opts.typeField] - Resource type field on wire objects
+   * @param {'offset'|'page'} [opts.paginationStyle] - Query param style for list fetches
+   * @param {string} [opts.offsetParam] - Offset query parameter name
+   * @param {string} [opts.limitParam] - Page size query parameter name
+   * @param {string} [opts.pageParam] - Page number query parameter name (1-based)
+   * @param {boolean} [opts.embedRelationships] - Embed nested objects on write (default: id stub)
+   */
+  constructor(opts = {}) {
+    this.itemsPath = opts.itemsPath ?? null;
+    this.itemPath = opts.itemPath ?? null;
+    this.totalPath = opts.totalPath ?? null;
+    this.offsetPath = opts.offsetPath ?? null;
+    this.idField = opts.idField ?? "id";
+    this.typeField = opts.typeField ?? "type";
+    this.paginationStyle = opts.paginationStyle ?? "offset";
+    this.offsetParam = opts.offsetParam ?? "offset";
+    this.limitParam = opts.limitParam ?? "limit";
+    this.pageParam = opts.pageParam ?? "page";
+    this.embedRelationships = opts.embedRelationships ?? false;
+  }
+  /**
+   * @param {object|Array} data
+   * @returns {boolean}
+   */
+  isSingleItemResponse(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+      return false;
+    }
+    if (this.itemPath) {
+      const item = getPath(data, this.itemPath);
+      if (Array.isArray(item)) {
+        return false;
+      }
+      if (item && typeof item === "object") {
+        return item[this.idField] != null;
+      }
+      return false;
+    }
+    const rows = extractCollectionRows(data, this.itemsPath);
+    if (rows.length > 0) {
+      return false;
+    }
+    if (data.data && Array.isArray(data.data)) {
+      return false;
+    }
+    if (data.data && typeof data.data === "object" && data.data[this.idField] != null) {
+      return true;
+    }
+    return data[this.idField] != null;
+  }
+  /**
+   * @param {object} data
+   * @returns {{ totalRecords?: number, offset?: number }}
+   */
+  extractMetadata(data) {
+    const meta = {};
+    const totalRecords = extractTotalRecords(data, this.totalPath);
+    if (totalRecords !== void 0) {
+      meta.totalRecords = totalRecords;
+    }
+    const offset = extractOffset(data, this.offsetPath);
+    if (offset !== void 0) {
+      meta.offset = offset;
+    }
+    return meta;
+  }
+  /**
+   * @param {object} collection
+   * @param {{ totalRecords?: number, offset?: number }} meta
+   */
+  applyMetadata(collection, meta) {
+    if (meta.totalRecords !== void 0) {
+      collection.total = meta.totalRecords;
+    }
+    if (meta.offset !== void 0) {
+      collection.offset = meta.offset;
+    }
+  }
+  /**
+   * @param {object} data
+   * @param {object} [options]
+   * @returns {object}
+   */
+  parseItemResponse(data, options = {}) {
+    this.validateItemRemoteDoc(data, options);
+    const raw = this.extractRawItem(data);
+    const defaultType = options.collection?.type ?? options.type;
+    return this.normalize(raw, defaultType);
+  }
+  /**
+   * @param {object} data
+   */
+  validateItemRemoteDoc(data) {
+    if (Array.isArray(data)) {
+      throw new Error("Invalid configuration: resource type is item but server response is collection");
+    }
+    if (this.itemPath) {
+      const item = getPath(data, this.itemPath);
+      if (Array.isArray(item)) {
+        throw new Error("Invalid configuration: resource type is item but server response is collection");
+      }
+      return;
+    }
+    if (data?.data && Array.isArray(data.data)) {
+      throw new Error("Invalid configuration: resource type is item but server response is collection");
+    }
+  }
+  /**
+   * @param {object} data
+   * @returns {string|undefined}
+   */
+  inferItemType(data) {
+    const raw = this.extractRawItem(data);
+    if (!raw || typeof raw !== "object") {
+      return void 0;
+    }
+    return raw[this.typeField];
+  }
+  /**
+   * @param {object|Array} doc
+   * @param {object} [options]
+   * @returns {{ items: Array<object>, meta: object }}
+   */
+  parseCollectionResponse(doc, options = {}) {
+    const rows = extractCollectionRows(doc, this.itemsPath);
+    const defaultType = options.type;
+    const items = rows.map((row) => this.normalize(row, defaultType));
+    const meta = this.extractMetadata(doc);
+    return { items, meta };
+  }
+  /**
+   * @param {import('../URL.js').URL} url
+   * @param {{ offset?: number, pageSize?: number }} params
+   */
+  applyListQuery(url, params) {
+    const { offset, pageSize } = params;
+    if (typeof pageSize === "undefined" || pageSize === null) {
+      return;
+    }
+    if (this.paginationStyle === "page") {
+      const safeOffset = typeof offset === "undefined" || offset === null ? 0 : offset;
+      const page = Math.floor(safeOffset / pageSize) + 1;
+      url.parameters[this.pageParam] = page;
+      url.parameters[this.limitParam] = pageSize;
+      return;
+    }
+    if (typeof offset !== "undefined" && offset !== null) {
+      url.parameters[this.offsetParam] = offset;
+    }
+    url.parameters[this.limitParam] = pageSize;
+  }
+  /**
+   * @param {object|Array} itemData
+   * @param {object} [context]
+   * @returns {{ body: string, contentType: string }}
+   */
+  serializeForCreate(itemData, context = {}) {
+    const defaultType = context.type;
+    let payload;
+    if (Array.isArray(itemData)) {
+      payload = itemData.map((item) => this.flattenForWire(this.coerceToCanonical(item, defaultType)));
+    } else {
+      payload = this.flattenForWire(this.coerceToCanonical(itemData, defaultType));
+    }
+    return {
+      body: JSON.stringify(payload),
+      contentType: "application/json"
+    };
+  }
+  /**
+   * @param {object} toUpdate
+   * @returns {{ body: string, contentType: string }}
+   */
+  serializeForUpdate(toUpdate) {
+    const relationships = {};
+    Object.entries(toUpdate.relationships || {}).forEach(([name, rel]) => {
+      relationships[name] = this.unwrapRelationship(rel);
+    });
+    const payload = this.flattenForWire({
+      id: toUpdate.id,
+      type: toUpdate.type,
+      attributes: toUpdate.attributes,
+      relationships
+    });
+    return {
+      body: JSON.stringify(payload),
+      contentType: "application/json"
+    };
+  }
+  /**
+   * @param {object|Array|null} rel
+   * @returns {object|Array|null|undefined}
+   */
+  serializeRelationship(rel) {
+    return this.unwrapRelationship(rel);
+  }
+  /**
+   * @param {object} data
+   * @returns {object}
+   * @private
+   */
+  extractRawItem(data) {
+    if (this.itemPath) {
+      return getPath(data, this.itemPath);
+    }
+    if (data?.data && typeof data.data === "object" && !Array.isArray(data.data)) {
+      return data.data;
+    }
+    return data;
+  }
+  /**
+   * @param {object} row
+   * @param {string|undefined} defaultType
+   * @returns {object}
+   */
+  normalize(row, defaultType) {
+    if (!row || typeof row !== "object" || Array.isArray(row)) {
+      throw new Error("Invalid item data: must be an object");
+    }
+    if (row.attributes && typeof row.attributes === "object") {
+      const relationships2 = {};
+      Object.entries(row.relationships || {}).forEach(([name, value]) => {
+        if (value === null) {
+          relationships2[name] = null;
+        } else if (Array.isArray(value)) {
+          relationships2[name] = value.map((entry) => this.normalize(entry, defaultType));
+        } else {
+          relationships2[name] = this.normalize(value, defaultType);
+        }
+      });
+      const normalized2 = {
+        attributes: { ...row.attributes },
+        relationships: relationships2
+      };
+      if (row.id != null) {
+        normalized2.id = String(row.id);
+      }
+      if (row.type ?? defaultType) {
+        normalized2.type = row.type ?? defaultType;
+      }
+      return normalized2;
+    }
+    const attributes = {};
+    const relationships = {};
+    let id;
+    let type;
+    Object.entries(row).forEach(([key, value]) => {
+      if (key === this.idField) {
+        id = value;
+        return;
+      }
+      if (key === this.typeField) {
+        type = value;
+        return;
+      }
+      if (value === null || value === void 0) {
+        attributes[key] = value;
+        return;
+      }
+      if (Array.isArray(value)) {
+        if (value.length > 0 && value.every((entry) => this.isNestedResource(entry))) {
+          relationships[key] = value.map((entry) => this.normalize(entry, defaultType));
+        } else {
+          attributes[key] = value;
+        }
+        return;
+      }
+      if (this.isNestedResource(value)) {
+        relationships[key] = this.normalize(value, defaultType);
+        return;
+      }
+      attributes[key] = value;
+    });
+    const normalized = { attributes, relationships };
+    if (id != null) {
+      normalized.id = String(id);
+    }
+    if (type ?? defaultType) {
+      normalized.type = type ?? defaultType;
+    }
+    return normalized;
+  }
+  /**
+   * @param {*} value
+   * @returns {boolean}
+   * @private
+   */
+  isNestedResource(value) {
+    return value && typeof value === "object" && !Array.isArray(value) && value[this.idField] != null;
+  }
+  /**
+   * @param {object} data
+   * @param {string|undefined} defaultType
+   * @returns {object}
+   * @private
+   */
+  coerceToCanonical(data, defaultType) {
+    if (!data || typeof data !== "object") {
+      return data;
+    }
+    if (data.attributes || data.relationships) {
+      return data;
+    }
+    return this.normalize(data, defaultType);
+  }
+  /**
+   * @param {object} canonical
+   * @returns {object}
+   * @private
+   */
+  flattenForWire(canonical) {
+    if (!canonical || typeof canonical !== "object") {
+      return canonical;
+    }
+    const result = { ...canonical.attributes || {} };
+    if (canonical.id != null) {
+      result[this.idField] = canonical.id;
+    }
+    if (canonical.type != null && this.typeField) {
+      result[this.typeField] = canonical.type;
+    }
+    Object.entries(canonical.relationships || {}).forEach(([name, rel]) => {
+      if (rel === null) {
+        result[name] = null;
+        return;
+      }
+      if (Array.isArray(rel)) {
+        result[name] = rel.map((entry) => this.relationshipToWire(entry));
+        return;
+      }
+      result[name] = this.relationshipToWire(rel);
+    });
+    return result;
+  }
+  /**
+   * @param {object|null|undefined} rel
+   * @returns {object|null|undefined}
+   * @private
+   */
+  relationshipToWire(rel) {
+    if (!rel) {
+      return null;
+    }
+    if (this.embedRelationships && rel.attributes) {
+      return this.flattenForWire(rel);
+    }
+    const stub = { [this.idField]: rel.id ?? rel[this.idField] };
+    if ((rel.type ?? rel[this.typeField]) != null) {
+      stub[this.typeField] = rel.type ?? rel[this.typeField];
+    }
+    return stub;
+  }
+  /**
+   * @param {*} rel
+   * @returns {object|Array|null|undefined}
+   * @private
+   */
+  unwrapRelationship(rel) {
+    if (rel == null) {
+      return null;
+    }
+    if (rel.data !== void 0) {
+      if (rel.data === null) {
+        return null;
+      }
+      if (Array.isArray(rel.data)) {
+        return rel.data.map((entry) => ({ ...entry }));
+      }
+      return { ...rel.data };
+    }
+    if (Array.isArray(rel)) {
+      return rel.map((entry) => this.unwrapRelationship(entry));
+    }
+    if (typeof rel === "object") {
+      if (rel.attributes) {
+        return rel;
+      }
+      return { ...rel };
+    }
+    return rel;
+  }
+};
+
+// src/adapters/resolveAdapter.js
+var registry = /* @__PURE__ */ new Map([
+  ["jsonapi", new JsonApiAdapter()],
+  ["plain", new PlainRestAdapter()]
+]);
+var defaultAdapter = "jsonapi";
+function registerAdapter(name, adapter) {
+  if (!name || typeof name !== "string") {
+    throw new Error("Adapter name must be a non-empty string");
+  }
+  registry.set(name, adapter);
+}
+function setDefaultAdapter(adapter) {
+  defaultAdapter = adapter;
+}
+function getDefaultAdapter() {
+  return defaultAdapter;
+}
+function resolveAdapter(adapter) {
+  if (adapter && typeof adapter === "object") {
+    return adapter;
+  }
+  const name = typeof adapter === "string" ? adapter : defaultAdapter;
+  if (typeof name === "object") {
+    return name;
+  }
+  const resolved = registry.get(name);
+  if (!resolved) {
+    throw new Error(`Unknown data adapter: ${name}`);
+  }
+  return resolved;
+}
+
+// src/ItemView.js
+var ItemView = class {
+  constructor(params) {
+    if (params && params.isView) {
+      return params;
+    }
+    this.type = "ItemView";
+    this.dataBindings = null;
+    this.template = null;
+    this.container = null;
+    this.collectionView = null;
+    this.item = null;
+    this.el = null;
+    this.id = uid();
+    this.isView = true;
+    this.callbacks = {};
+    if (params && (params.length || params.nodeName && !params.jquery)) {
+      dbg("params is actually a jquery object or an html node", params);
+      let $el = $(params);
+      if ($el.data("view")) {
+        return $el.data("view");
+      }
+      let tmp = $("<div>").append($el.clone(true));
+      let html = tmp.html().replace(/&lt;%/gi, "<%").replace(/&lt;/gi, "<").replace(/%&gt;/gi, "%>").replace(/&gt;/gi, ">").replace(/&amp;/gi, "&");
+      params = {
+        template: template(html),
+        el: $el
+      };
+      if ($el.attr("id")) {
+        params.id = $el.attr("id");
+      }
+      tmp.remove();
+    }
+    try {
+      params = parseOptions(params);
+    } catch (e) {
+      throw new Error("Error on ItemView", this, e);
+    }
+    Object.assign(this, params);
+    if (this.el !== null) {
+      this.dataBindings = getBoundObjects(this.el);
+    }
+  }
+  /**
+   * Event listener registration
+   */
+  on(event, cb) {
+    if (!this.callbacks[event]) {
+      this.callbacks[event] = [];
+    }
+    this.callbacks[event].push(cb);
+    return this;
+  }
+  /**
+   * Unbind from item
+   */
+  unbind() {
+    if (this.item) {
+      this.item.unbindView(this);
+    }
+  }
+  /**
+   * Create element from template
+   */
+  createElementFromTemplate() {
+    if (this.template == null) {
+      dbg("Warning: no template defined. Nothing to render");
+      return null;
+    }
+    if (!this.item) {
+      dbg("Warning: no item bound to view. Cannot render template.");
+      return null;
+    }
+    let el;
+    try {
+      const renderContext = this.item.getRenderContext();
+      console.log("renderContext", renderContext);
+      let html = this.template(renderContext);
+      el = $(html).attr("data-type", "item").attr("id", this.id).data("view", this).data("instance", this.item);
+    } catch (e) {
+      console.log("Error create view from template", e, this.item);
+      el = $("<div>Could not render view: <strong>" + e.toString() + "</strong></div>");
+    }
+    return el;
+  }
+  /**
+   * After render callback
+   */
+  afterrender() {
+    if (!this.callbacks.afterrender) {
+      return;
+    }
+    console.log("afterend of view", this);
+    this.callbacks.afterrender.forEach((cb) => cb(this));
+  }
+  /**
+   * Render the view
+   */
+  render(doNotAttachToContainer = false, addontop = false) {
+    log("ItemView.render called", this.item, this.el);
+    let renderedEl = this.createElementFromTemplate();
+    if (!renderedEl) {
+      return null;
+    }
+    log("View item", this.item);
+    if (this.item && this.item.uievents) {
+      log("UI events", this.item.uievents);
+      this.item.uievents.forEach((action) => {
+        log("UI event", action, renderedEl);
+        if (action.selector && action.event && action.callback) {
+          const actionEls = $(renderedEl).find(action.selector);
+          log("UI event els", action, renderedEl, actionEls);
+          actionEls.on(action.event, (event) => {
+            event.preventDefault();
+            log("UIevent triggered", event, this.item, this);
+            action.callback(event, this.item, this);
+          });
+        }
+      });
+    }
+    if (doNotAttachToContainer) {
+      this.el = renderedEl;
+      return this.el;
+    }
+    if (this.el) {
+      let oldEl = this.el;
+      if (!oldEl.jquery) {
+        oldEl = $(oldEl);
+      }
+      oldEl.off();
+      this.el = $(renderedEl).insertBefore(oldEl);
+      oldEl.remove();
+      this.afterrender();
+      return this;
+    }
+    this.el = renderedEl;
+    this.afterrender();
+    if (!this.container) {
+      return this;
+    }
+    $(this.el).appendTo(this.container.el);
+    return this;
+  }
+  /**
+   * Render empty state
+   */
+  renderEmpty(returnView) {
+    if (this.item && this.item.emptyview && this.el) {
+      let emptyView = $(this.item.emptyview).clone(true).css("display", "block");
+      $(this.el).replaceWith(emptyView);
+    }
+  }
+  /**
+   * Remove view with animation
+   */
+  remove(idx) {
+    return new Promise((resolve) => {
+      if (this.item && this.item.collection) {
+        this.item.collection._trigger("afterrender", this.item.collection);
+      }
+      if (this.el) {
+        let $el = this.el.jquery ? this.el : $(this.el);
+        $el.fadeOut({
+          complete: () => {
+            $el.remove();
+            resolve();
+          }
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+  /**
+   * Destroy view and clean up resources
+   * 
+   * Removes event handlers, jQuery data, and DOM references
+   */
+  destroy() {
+    if (this.el) {
+      const $el = this.el.jquery ? this.el : $(this.el);
+      $el.off();
+      $el.removeData();
+    }
+    this.callbacks = {};
+    if (this.item) {
+      this.item.unbindView(this);
+    }
+    this.item = null;
+    this.container = null;
+    this.collectionView = null;
+    this.el = null;
+    this.template = null;
+    this.dataBindings = null;
+    return this;
+  }
+};
+
+// src/Item.js
+var Item = class _Item {
+  constructor(options = {}, data = null) {
+    this.id = null;
+    this.type = null;
+    this.attributes = {};
+    this.relationships = {};
+    this.views = [];
+    this.collection = null;
+    this.url = null;
+    this.updateUrl = null;
+    this.deleteUrl = null;
+    this.strict = false;
+    this.shadow = null;
+    this.syncOp = null;
+    this.emptyview = null;
+    this.uievents = [];
+    this.callbacks = {};
+    this.adapter = null;
+    try {
+      Object.assign(this, parseOptions(options));
+    } catch (e) {
+      throw new Error("Error on Item init", e);
+    }
+    this.adapter = resolveAdapter(
+      options.adapter ?? (options.collection && options.collection.adapter)
+    );
+    this.storage = options.storage || new Storage(
+      (() => {
+        const storageOpts = Object.assign({}, options.ajaxOpts || {});
+        if (options.headers && typeof options.headers === "object") {
+          storageOpts.headers = Object.assign(
+            {},
+            storageOpts.headers || {},
+            options.headers
+          );
+        }
+        return storageOpts;
+      })()
+    );
+    let render = false;
+    if (data) {
+      log("Loading data", data);
+      try {
+        this.loadFromData(data);
+        render = true;
+      } catch (e) {
+        console.error("Error loading data", e);
+      }
+    }
+    if (this.url) {
+      this.setUrl(this.url);
+    }
+    if (this.deleteUrl) {
+      log("deleteUrl", this.deleteUrl);
+      this.setUrl(this.deleteUrl, "delete");
+    }
+    if (this.updateUrl) {
+      this.setUrl(this.updateUrl, "update");
+    }
+    if (this.insertUrl) {
+      this.setUrl(this.insertUrl, "insert");
+    }
+    this.views.forEach((view) => {
+      view.item = this;
+    });
+    if (options.itemListeners && typeof options.itemListeners === "object") {
+      Object.getOwnPropertyNames(options.itemListeners).forEach((eventName) => {
+        log("apply item listener", eventName, options.itemListeners[eventName]);
+        this.on(eventName, options.itemListeners[eventName]);
+      });
+    }
+    if (render) {
+      log("Rendering data", data);
+      this.render();
+    }
+  }
+  /**
+   * Event listener registration
+   */
+  on(eventName, cb) {
+    if (typeof this.callbacks[eventName] === "undefined") {
+      this.callbacks[eventName] = [];
+    }
+    this.callbacks[eventName].push(cb);
+    return this;
+  }
+  /**
+   * Remove event listener(s)
+   * @param {string} eventName - Event name
+   * @param {Function} [cb] - Optional callback to remove. If not provided, removes all listeners for the event
+   * @returns {Item} This instance for chaining
+   */
+  off(eventName, cb) {
+    if (!eventName) {
+      this.callbacks = {};
+      return this;
+    }
+    if (!this.callbacks[eventName]) {
+      return this;
+    }
+    if (cb) {
+      const index = this.callbacks[eventName].indexOf(cb);
+      if (index > -1) {
+        this.callbacks[eventName].splice(index, 1);
+      }
+      if (this.callbacks[eventName].length === 0) {
+        delete this.callbacks[eventName];
+      }
+    } else {
+      delete this.callbacks[eventName];
+    }
+    return this;
+  }
+  /**
+   * Register a one-time event listener
+   * @param {string} eventName - Event name
+   * @param {Function} cb - Callback function
+   * @returns {Item} This instance for chaining
+   */
+  once(eventName, cb) {
+    const wrapper = (...args) => {
+      cb(...args);
+      this.off(eventName, wrapper);
+    };
+    return this.on(eventName, wrapper);
+  }
+  /**
+   * Check if event has listeners
+   * @param {string} eventName - Event name
+   * @returns {boolean} True if event has listeners
+   */
+  hasListeners(eventName) {
+    return this.callbacks[eventName] && Array.isArray(this.callbacks[eventName]) && this.callbacks[eventName].length > 0;
+  }
+  /**
+   * Trigger an event (internal helper)
+   * @private
+   * @param {string} eventName - Event name
+   * @param {...any} args - Arguments to pass to callbacks
+   */
+  _trigger(eventName, ...args) {
+    if (this.callbacks[eventName] && Array.isArray(this.callbacks[eventName])) {
+      this.callbacks[eventName].forEach((cb) => {
+        if (typeof cb === "function") {
+          cb(...args);
+        }
+      });
+    }
+  }
+  /**
+   * Emit/trigger an event manually
+   * @param {string} eventName - Event name
+   * @param {...any} args - Arguments to pass to callbacks
+   * @returns {Item} This instance for chaining
+   */
+  emit(eventName, ...args) {
+    this._trigger(eventName, ...args);
+    return this;
+  }
+  /**
+   * Set URL for this item
+   */
+  setUrl(url, type) {
+    switch (type) {
+      case "delete":
+        this.deleteUrl = createURL(url);
+        break;
+      case "update":
+        this.updateUrl = createURL(url);
+        break;
+      case "insert":
+        this.insertUrl = createURL(url);
+        break;
+      default:
+        this.url = createURL(url);
+        this.deleteUrl = typeof this.deleteUrl == "string" ? createURL(this.deleteUrl) : this.deleteUrl ?? createURL(this.url);
+        this.updateUrl = typeof this.updateUrl == "string" ? createURL(this.updateUrl) : this.updateUrl ?? createURL(this.url);
+        break;
+    }
+    return this;
+  }
+  /**
+   * Load from remote
+   * 
+   * Canonical method for loading item data from API
+   */
+  loadFromRemote() {
+    return this.loadFromDataSource();
+  }
+  load(data) {
+    return data ? this.loadFromData(data) : this.loadFromRemote();
+  }
+  /**
+   * Load from data source (internal implementation)
+   * @private
+   */
+  loadFromDataSource() {
+    let loaders = [];
+    const overlay = createOverlay(this);
+    this.views.forEach((itemView) => {
+      if (itemView.el) {
+        let $el = $(itemView.el);
+        let loader = overlay.clone();
+        loader.insertBefore(itemView.el).width($el.width()).height($el.height());
+        loaders.push(loader);
+      }
+    });
+    return new Promise((resolve, reject) => {
+      if (!this.url) {
+        reject(new Error("No valid URL provided"));
+        return;
+      }
+      this._trigger("beforeload", this);
+      let urlString = this.url.toString ? this.url.toString() : this.url;
+      this.storage.read(this, urlString, {}).then((resp) => {
+        let data = resp.data;
+        this.loadFromRemoteDoc(data).render();
+        this._trigger("load", this);
+        loaders.forEach((loader) => {
+          loader.remove();
+        });
+        resolve(this);
+      }).catch((error2) => {
+        dbg("fail to load item resource", this.url, error2);
+        if (error2 instanceof Error && error2.jqXHR) {
+          this.fail(error2.jqXHR, error2.textStatus || "error", error2.errorThrown || error2);
+          reject(error2);
+        } else if (error2 && error2.jqXHR) {
+          this.fail(error2.jqXHR, error2.textStatus, error2.errorThrown);
+          reject(error2);
+        } else {
+          this.fail(null, "error", error2);
+          reject(error2);
+        }
+      });
+    });
+  }
+  /**
+   * @deprecated Use loadFromRemote() instead
+   * Alias for backward compatibility
+   */
+  refresh() {
+    return this.loadFromRemote();
+  }
+  /**
+   * @deprecated Use loadFromRemote() instead
+   * Alias for backward compatibility
+   */
+  reload() {
+    return this.loadFromRemote();
+  }
+  /**
+   * @deprecated Use loadFromRemote() instead
+   * Internal method, use loadFromRemote() for public API
+   * @private
+   */
+  load_from_data_source() {
+    return this.loadFromDataSource();
+  }
+  /**
+   * Unbind a view from this item
+   */
+  unbindView(view) {
+    let found = false;
+    for (let i = 0; i < this.views.length; i++) {
+      if (this.views[i] === view) {
+        found = i;
+      }
+    }
+    if (found !== false) {
+      this.views.splice(found, 1);
+    }
+  }
+  /**
+   * Bind a view to this item
+   */
+  bindView(view, returnView) {
+    let $el = $(view);
+    if ($el.length === 0) {
+      throw new Error("Nothing to bind to: empty view element");
+    }
+    if (!(view instanceof ItemView)) {
+      view = new ItemView(view);
+    }
+    let bound = false;
+    this.views.forEach((v) => {
+      dbg("bind to existing view", v.el);
+      if (v === view) {
+        bound = true;
+      }
+    });
+    if (bound) {
+      return returnView ? view : this;
+    }
+    view.item = this;
+    this.views.push(view);
+    return returnView ? view : this;
+  }
+  /**
+   * Load from a remote API document (format determined by adapter).
+   *
+   * @param {object} data - Raw HTTP response body
+   * @returns {Item} This instance for chaining
+   */
+  loadFromRemoteDoc(data) {
+    dbg("Load from remote doc", data);
+    if (this.collection && !this.collection.type) {
+      const inferredType = this.adapter.inferItemType(data);
+      if (inferredType) {
+        this.type = inferredType;
+      }
+    }
+    this.adapter.validateItemRemoteDoc(data, { collection: this.collection });
+    const parsedData = this.adapter.parseItemResponse(data, { collection: this.collection });
+    Object.assign(this, parsedData);
+    if (this.url) {
+      this.url = createURL(this.url);
+    }
+    return this;
+  }
+  /**
+   * @deprecated Use loadFromRemoteDoc() instead
+   * @param {object} data - Raw HTTP response body
+   * @returns {Item} This instance for chaining
+   */
+  loadFromJSONAPIDoc(data) {
+    return this.loadFromRemoteDoc(data);
+  }
+  /**
+   * Load from data object
+   */
+  loadFromData(data, render = false) {
+    if (data === null || typeof data !== "object" || data.constructor !== Object) {
+      dbg("cannot load ", data, " into ", this);
+      throw new Error("Cannot load data into item");
+    }
+    if (!data.hasOwnProperty("attributes") && !data.hasOwnProperty("id") && !data.hasOwnProperty("type")) {
+      dbg("need to normalize data", data);
+      let attributes = {};
+      let relationships = {};
+      Object.getOwnPropertyNames(data).forEach((propName) => {
+        if (data[propName] && data[propName].constructor === Object) {
+          relationships[propName] = new _Item().loadFromData(data[propName]);
+          return;
+        }
+        if (data[propName] && data[propName].constructor === Array) {
+          relationships[propName] = data[propName];
+          return;
+        }
+        attributes[propName] = data[propName];
+      });
+      data = {
+        attributes
+      };
+      if (Object.getOwnPropertyNames(relationships).length) {
+        data.relationships = relationships;
+      }
+    }
+    Object.assign(this, data);
+    this._trigger("load", this);
+    if (render) {
+      this.render();
+    }
+    return this;
+  }
+  /**
+   * Handle failure
+   */
+  fail(xhr, statusText, error2) {
+    dbg("item.fail", xhr, statusText, error2);
+    this.views.forEach((view) => {
+      if (xhr && xhr.status === 404) {
+        view.renderEmpty();
+      }
+    });
+  }
+  /**
+   * Get render context - safe view model for templates
+   * 
+   * RENDER CONTEXT CONTRACT:
+   * 
+   * Returns a template-friendly object where:
+   * - Attributes are exposed directly (e.g., {{title}} not {{attributes.title}})
+   * - Relationships are flattened to plain objects with attributes, id, type
+   * - All data is shallow-copied to prevent mutation of internal state
+   * 
+   * Relationship representation strategy:
+   * - To-one: { id, type, ...attributes } (flattened plain object)
+   * - To-many: Array of { id, type, ...attributes } (array of flattened objects)
+   * - Null relationships: null
+   * 
+   * This ensures Handlebars templates can access data directly:
+   *   {{title}} - item attribute
+   *   {{author.name}} - relationship attribute
+   *   {{#each tags}}{{name}}{{/each}} - relationship array
+   * 
+   * @returns {Object} Render context object safe for template rendering
+   */
+  getRenderContext() {
+    function deepCloneStatic(value, seen = /* @__PURE__ */ new WeakMap()) {
+      if (value === null || typeof value !== "object") {
+        return value;
+      }
+      if (seen.has(value)) {
+        return seen.get(value);
+      }
+      if (Array.isArray(value)) {
+        const clonedArray = [];
+        seen.set(value, clonedArray);
+        value.forEach((item) => clonedArray.push(deepCloneStatic(item, seen)));
+        return clonedArray;
+      }
+      const clonedObject = {};
+      seen.set(value, clonedObject);
+      Object.keys(value).forEach((key) => {
+        clonedObject[key] = deepCloneStatic(value[key], seen);
+      });
+      return clonedObject;
+    }
+    function isResourceNode(obj) {
+      return obj instanceof _Item || obj.attributes != null && typeof obj.attributes === "object";
+    }
+    function isReferenceStub(obj) {
+      if (!obj || typeof obj !== "object" || Array.isArray(obj) || isResourceNode(obj)) {
+        return false;
+      }
+      if (obj.id == null) {
+        return false;
+      }
+      return Object.keys(obj).every((key) => key === "id" || key === "type");
+    }
+    function copyntransform(obj, cache = /* @__PURE__ */ new WeakMap()) {
+      if (!obj) {
+        return null;
+      }
+      if (typeof obj !== "object") {
+        return obj;
+      }
+      if (cache.has(obj)) {
+        return cache.get(obj);
+      }
+      if (isReferenceStub(obj)) {
+        const stub = { id: obj.id };
+        cache.set(obj, stub);
+        return stub;
+      }
+      if (!isResourceNode(obj)) {
+        if (obj.id != null) {
+          const flat = { id: obj.id };
+          Object.keys(obj).forEach((key) => {
+            if (key === "id" || key === "type" || key === "relationships" || key === "attributes") {
+              return;
+            }
+            flat[key] = deepCloneStatic(obj[key]);
+          });
+          cache.set(obj, flat);
+          return flat;
+        }
+        const cloned = deepCloneStatic(obj);
+        cache.set(obj, cloned);
+        return cloned;
+      }
+      const result = { id: obj.id };
+      cache.set(obj, result);
+      Object.assign(result, deepCloneStatic(obj.attributes ?? {}));
+      Object.keys(obj.relationships ?? {}).forEach((relName) => {
+        if (Array.isArray(obj.relationships[relName])) {
+          result[relName] = obj.relationships[relName].map((item) => copyntransform(item, cache));
+        } else {
+          result[relName] = copyntransform(obj.relationships[relName], cache);
+        }
+      });
+      return result;
+    }
+    return copyntransform(this);
+  }
+  /**
+   * Convert to JSON:API format
+   * 
+   * Serializes item to JSON:API format for API requests.
+   * This method is side-effect free - it does not mutate this.relationships.
+   * 
+   * Runtime relationships (hydrated objects) are converted to JSON:API
+   * relationship format: { data: { type, id } } or { data: [{ type, id }, ...] }
+   * 
+   * @returns {Object} JSON:API formatted object
+   */
+  toJSON() {
+    let json = {
+      type: this.type,
+      attributes: this.attributes || {}
+    };
+    if (this.id) {
+      json.id = this.id;
+    }
+    if (this.relationships && Object.keys(this.relationships).length > 0) {
+      json.relationships = {};
+      for (let relName in this.relationships) {
+        if (!this.relationships.hasOwnProperty(relName)) {
+          continue;
+        }
+        const rel = this.relationships[relName];
+        if (rel === null) {
+          json.relationships[relName] = { data: null };
+          continue;
+        }
+        if (rel && typeof rel === "object" && !Array.isArray(rel)) {
+          if (rel.type && rel.id) {
+            json.relationships[relName] = {
+              data: {
+                type: rel.type,
+                id: rel.id
+              }
+            };
+          } else if (rel.hasOwnProperty("toJSON")) {
+            json.relationships[relName] = {
+              data: rel.toJSON()
+            };
+          } else {
+            continue;
+          }
+          continue;
+        }
+        if (Array.isArray(rel)) {
+          json.relationships[relName] = {
+            data: rel.map((item) => {
+              if (item && typeof item === "object") {
+                if (item.type && item.id) {
+                  return {
+                    type: item.type,
+                    id: item.id
+                  };
+                } else if (item.hasOwnProperty("toJSON")) {
+                  return item.toJSON();
+                }
+              }
+              return item;
+            })
+          };
+          continue;
+        }
+        continue;
+      }
+    }
+    dbg("item.json", json);
+    return json;
+  }
+  /**
+   * Serialize a single relationship to JSON:API wire format
+   * 
+   * Converts runtime relationship state (hydrated objects, arrays, null) to
+   * JSON:API relationship format for wire transmission.
+   * 
+   * IMPORTANT: This is a serialization function - it does NOT mutate runtime state.
+   * Runtime relationships remain as hydrated objects/arrays/null.
+   * 
+   * @param {Object|Array|null} rel - Runtime relationship value
+   * @returns {Object} JSON:API relationship format: { data: { type, id } } or { data: [{ type, id }, ...] } or { data: null }
+   */
+  _serializeRelationshipToWireFormat(rel) {
+    return this.adapter.serializeRelationship(rel);
+  }
+  /**
+   * Sync pending operations
+   */
+  sync() {
+    if (this.syncOp) {
+      let syncOp = this.syncOp;
+      dbg("Syncing", this, syncOp);
+      this.syncOp = null;
+      return syncOp();
+    } else {
+      dbg("Nothing to sync on", this);
+    }
+  }
+  /**
+   * Perform update operation
+   * 
+   * Builds PATCH payload with changed attributes and relationships.
+   * 
+   * IMPORTANT: Runtime relationship state (hydrated objects/arrays/null) is serialized
+   * to JSON:API wire format ({ data: { type, id } }) for transmission. Runtime state
+   * remains unchanged - this is a serialization layer, not a state mutation.
+   */
+  perform_update(opts) {
+    let options = {
+      rerender: true
+    };
+    Object.assign(options, opts);
+    return new Promise((resolve, reject) => {
+      let toUpdate = {
+        id: this.id,
+        attributes: {},
+        relationships: {}
+      };
+      if (this.type) {
+        toUpdate.type = this.type;
+      }
+      Object.getOwnPropertyNames(this.attributes).forEach((attrName) => {
+        if (this.shadow && this.shadow.attributes[attrName] !== this.attributes[attrName]) {
+          toUpdate.attributes[attrName] = this.attributes[attrName];
+        }
+      });
+      Object.getOwnPropertyNames(this.relationships).forEach((relaName) => {
+        if (this.shadow && this.shadow.relationships[relaName] !== this.relationships[relaName]) {
+          const runtimeRel = this.relationships[relaName];
+          toUpdate.relationships[relaName] = this._serializeRelationshipToWireFormat(runtimeRel);
+        }
+      });
+      if (!Object.getOwnPropertyNames(toUpdate.attributes).length && !Object.getOwnPropertyNames(toUpdate.relationships).length) {
+        this.syncOp = null;
+        resolve(this);
+        return;
+      }
+      const payload = this.adapter.serializeForUpdate(toUpdate);
+      if (opts && opts.justSimulate) {
+        dbg(payload.body);
+        resolve(this);
+        return;
+      }
+      let updateUrlString = this.updateUrl.toString ? this.updateUrl.toString() : this.updateUrl;
+      this.storage.update(this, updateUrlString, { contentType: payload.contentType }, payload.body).then((resp) => {
+        let newData = this.adapter.parseItemResponse(resp.data);
+        Object.assign(this, newData);
+        this.shadow = null;
+        if (options.rerender) {
+          this.views.forEach((view) => {
+            view.render();
+            this._trigger("afterrender", this, view);
+          });
+        }
+        this._trigger("update", this);
+        if (this.collection) {
+          this.collection.onupdate();
+        }
+        resolve(this);
+      }).catch((error2) => {
+        dbg("Update NOK", this.updateUrl, patchData, error2);
+        if (error2 instanceof Error && error2.jqXHR) {
+          reject(error2);
+        } else if (error2.jqXHR) {
+          reject(error2);
+        } else {
+          reject(error2 instanceof Error ? error2 : new Error(String(error2)));
+        }
+      });
+    });
+  }
+  /**
+   * Update item
+   */
+  update(updateData, opts) {
+    if (!updateData || updateData.constructor !== Object) {
+      return;
+    }
+    let updateOptions = {
+      sync: true,
+      rerender: true
+    };
+    if (opts && opts.constructor === Object) {
+      Object.assign(updateOptions, opts);
+    }
+    if (!this.shadow) {
+      this.shadow = { attributes: {}, relationships: {} };
+      Object.assign(this.shadow.attributes, this.attributes);
+      Object.assign(this.shadow.relationships, this.relationships);
+    }
+    const updateRelation = (rel, data) => {
+      dbg("update relation", rel, data);
+      if (data === null) {
+        return null;
+      }
+      if (rel && Array.isArray(rel)) {
+        if (Array.isArray(data)) {
+          return data.map((item) => {
+            if (typeof item === "object" && item !== null) {
+              return new _Item().loadFromData(item);
+            }
+            return item;
+          });
+        }
+        dbg("to fix: array relationship update");
+        return rel;
+      }
+      if (typeof data === "object" || data === null) {
+        dbg("Update 1:1 relation");
+        let item = new _Item().loadFromData(data);
+        dbg("relation", item);
+        return item;
+      }
+      if (typeof data === "string" || typeof data === "number") {
+        dbg("Update 1:1 relation with id", data);
+        if (rel && rel.id && (rel.id === data || String(rel.id) === String(data))) {
+          return rel;
+        }
+        const newRel = {
+          id: String(data)
+        };
+        if (rel && rel.type) {
+          newRel.type = rel.type;
+        }
+        return newRel;
+      }
+      return rel;
+    };
+    Object.getOwnPropertyNames(this.relationships).forEach((relName) => {
+      if (!updateData.hasOwnProperty(relName)) {
+        return;
+      }
+      if (updateData[relName] === null) {
+        this.relationships[relName] = null;
+        return;
+      }
+      this.relationships[relName] = updateRelation(this.relationships[relName], updateData[relName]);
+      delete updateData[relName];
+    });
+    Object.getOwnPropertyNames(updateData).forEach((attrName) => {
+      if (updateData[attrName] && typeof updateData[attrName] === "object") {
+        if (!this.strict && typeof this.relationships[attrName] === "undefined") {
+          this.relationships[attrName] = updateRelation(this.relationships[attrName], updateData[attrName]);
+        }
+        return;
+      }
+      if (!this.shadow.attributes.hasOwnProperty(attrName)) {
+        if (!this.strict) {
+          this.attributes[attrName] = updateData[attrName];
+        }
+        return;
+      }
+      if (updateData[attrName] !== this.shadow.attributes[attrName]) {
+        this.attributes[attrName] = updateData[attrName];
+      }
+    });
+    dbg("updateOptions", updateOptions);
+    if (updateOptions.sync) {
+      return this.perform_update(updateOptions);
+    }
+    return new Promise((resolve) => {
+      this.syncOp = () => this.perform_update(updateOptions);
+      this.views.forEach((view) => {
+        if (updateOptions.rerender) {
+          view.render();
+        }
+      });
+      resolve();
+    });
+  }
+  /**
+   * Remove item
+   */
+  remove() {
+    return new Promise((resolve, reject) => {
+      let ps = [];
+      for (let i = this.views.length - 1; i >= 0; i--) {
+        ps.push(this.views[i].remove());
+      }
+      let collection = this.collection;
+      if (collection) {
+        ps.push(collection.removeItem(this));
+      }
+      Promise.all(ps).then(() => {
+        this._trigger("remove", this);
+        if (collection) {
+          console.log("removed");
+          collection.onupdate();
+        }
+      }).finally(() => resolve());
+    });
+  }
+  /**
+   * Delete item
+   */
+  async delete(ops) {
+    if (!this.deleteUrl) {
+      return this.remove();
+    }
+    let deleteOps = {
+      sync: true
+    };
+    if (ops && ops.constructor === Object) {
+      Object.assign(deleteOps, ops);
+    }
+    try {
+      log("delete", this.deleteUrl.toString());
+      await this.storage.delete(this, this.deleteUrl.toString(), {});
+      await this.remove();
+    } catch (error2) {
+      dbg("Error deleting item", error2);
+      throw error2;
+    }
+  }
+  /**
+   * Render item
+   */
+  render(collectionView, addontop = false) {
+    dbg("Render from item", this);
+    this.views.forEach((view) => {
+      if (typeof collectionView === "undefined") {
+        dbg("collectionView is undefined so render view");
+        view.render();
+      } else if (view.container === collectionView) {
+        dbg("collectionView matches view container so render view");
+        view.render(false, addontop);
+      }
+      dbg("trigger afterrender", this, view, view.el);
+      this._trigger("afterrender", this, view);
+    });
+    return this;
+  }
+  /**
+   * Destroy item and clean up resources
+   * 
+   * Removes event handlers, views, and clears references.
+   * Safe to call multiple times.
+   * 
+   * @returns {Item} This instance for chaining
+   */
+  destroy() {
+    const viewsToDestroy = this.views ? [...this.views] : [];
+    viewsToDestroy.forEach((view) => {
+      if (view && typeof view.destroy === "function") {
+        view.destroy();
+      }
+    });
+    this.views = [];
+    this.callbacks = {};
+    if (this.collection) {
+      this.collection = null;
+    }
+    this.storage = null;
+    this.url = null;
+    this.updateUrl = null;
+    this.deleteUrl = null;
+    this.attributes = {};
+    this.relationships = {};
+    this.shadow = null;
+    this.views = [];
+    return this;
+  }
+};
+
+// src/CollectionView.js
+var CollectionView = class {
+  constructor(options = {}) {
+    this.el = null;
+    this.type = "CollectionView";
+    this.container = null;
+    this.collection = null;
+    this.itemsContainer = null;
+    this.allowempty = true;
+    try {
+      Object.assign(this, parseOptions(options));
+    } catch (e) {
+      throw new Error("Error on CollectionView init", e);
+    }
+    this.dataBindings = getBoundObjects(this.el);
+  }
+  /**
+   * Reset the view
+   */
+  reset(force) {
+    if (this.allowempty || force) {
+      if (this.el) {
+        $(this.el).empty();
+      }
+    }
+    return this;
+  }
+  /**
+   * Render the collection view
+   */
+  render() {
+    dbg("Render _collectionView", this.collection);
+    if (this.collection && this.collection.navtype === "page") {
+      this.reset();
+    }
+    if (this.collection && this.collection.items.length === 0) {
+      this.renderEmpty();
+      return this;
+    }
+    if (this.collection) {
+      this.collection.items.forEach((item) => {
+        item.render(this);
+      });
+    }
+    return this;
+  }
+  /**
+   * Render empty state
+   */
+  renderEmpty() {
+    if (!this.collection || !this.collection.emptyview) {
+      return this;
+    }
+    this.reset();
+    $(this.el).append(this.collection.emptyview);
+    return this;
+  }
+  /**
+   * Destroy view and clean up resources
+   */
+  destroy() {
+    if (this.el) {
+      const $el = $(this.el);
+      $el.empty();
+      $el.removeData();
+    }
+    this.collection = null;
+    this.el = null;
+    this.container = null;
+    this.itemsContainer = null;
+    this.dataBindings = null;
+    return this;
+  }
+};
+
+// src/Paging.js
+var Paging = class {
+  constructor(pagingEl, collection) {
+    this.collection = collection;
+    this.el = $(pagingEl);
+    this.collection.paging = this;
+    this.iniOffset = (this.collection.offset ? this.collection.offset : 0) * 1;
+    this.defaultPageSize = 20;
+    this.pageSize = this.collection.pageSize;
+    this.setupPageSizeInput();
+    this.setupOffsetInput();
+    this.buttons = this.extractButtons();
+    log("buttons", this.buttons);
+    this.setupTotalCount();
+    this.render();
+  }
+  /**
+   * Setup page size input handler
+   */
+  setupPageSizeInput() {
+    let pageSizeInp = $(this.collection.pagesizeinp);
+    if (pageSizeInp.length) {
+      this.collection.setPageSize(pageSizeInp.val());
+      pageSizeInp.off("change").on("change", () => {
+        if (this.collection.setPageSize(pageSizeInp.val())) {
+          this.collection.loadFromRemote();
+        }
+      });
+    }
+  }
+  /**
+   * Setup offset input handler
+   */
+  setupOffsetInput() {
+    let offsetInp = $(this.collection.offsetinp);
+    if (offsetInp.length) {
+      this.collection.setOffset(offsetInp.val());
+      offsetInp.off("change").on("change", () => {
+        if (this.collection.setOffset(offsetInp.val())) {
+          this.collection.loadFromRemote();
+        }
+      });
+    }
+  }
+  /**
+   * Extract button templates from container
+   */
+  extractButtons() {
+    let buttons = {};
+    const pageBtn = $(this.el).find("[name=page]");
+    if (pageBtn.length) {
+      buttons.page = pageBtn.clone();
+      pageBtn.remove();
+    }
+    const prevBtn = $(this.el).find("[name=prev]");
+    if (prevBtn.length) {
+      buttons.prev = prevBtn.clone();
+      prevBtn.remove();
+    }
+    const nextBtn = $(this.el).find("[name=next]");
+    if (nextBtn.length) {
+      buttons.next = nextBtn.clone();
+      nextBtn.remove();
+    }
+    const firstBtn = $(this.el).find("[name=first]");
+    if (firstBtn.length) {
+      buttons.first = firstBtn.clone();
+      firstBtn.remove();
+    }
+    const lastBtn = $(this.el).find("[name=last]");
+    if (lastBtn.length) {
+      buttons.last = lastBtn.clone();
+      lastBtn.remove();
+    }
+    return buttons;
+  }
+  /**
+   * Setup total count element
+   */
+  setupTotalCount() {
+    this.$totalCount = $(this.collection.totalrecscount);
+  }
+  /**
+   * Clear container
+   */
+  clearContainer() {
+    $(this.el).empty();
+    $(this.el).find("[data-type=pages]").empty();
+  }
+  /**
+   * Update total count display
+   */
+  updateTotalCount(total) {
+    if (this.$totalCount && this.$totalCount.length) {
+      if (this.$totalCount[0].tagName === "INPUT") {
+        this.$totalCount.val(total);
+      } else {
+        this.$totalCount.text(total);
+      }
+    }
+  }
+  /**
+   * Create and append button element
+   */
+  appendButton(button, clickHandler, title) {
+    let btn = button.clone();
+    if (title !== void 0) {
+      btn.attr("title", title);
+    }
+    btn.on("click", clickHandler);
+    $(this.el).append(btn);
+    return btn;
+  }
+  /**
+   * Render pagination controls
+   */
+  render() {
+    const pagesToShow = 5;
+    const total = this.collection.total;
+    log("Paging render", total, this.buttons);
+    this.updateTotalCount(total);
+    this.clearContainer();
+    this.iniOffset = this.collection.offset * 1;
+    if (this.collection.pageSize) {
+      this.pageSize = this.collection.pageSize;
+    } else if (total - this.iniOffset - this.collection.items.length > 0) {
+      this.pageSize = this.collection.items.length;
+    } else {
+      this.pageSize = this.defaultPageSize;
+    }
+    this.pageSize = this.pageSize * 1;
+    log("Paging obj", this, this.pageSize, total);
+    if (this.pageSize > total) {
+      return;
+    }
+    if (this.iniOffset > 0) {
+      if (this.buttons.first) {
+        this.appendButton(
+          this.buttons.first,
+          () => {
+            this.collection.setOffset(0);
+            this.collection.loadFromRemote();
+          },
+          0
+        );
+      }
+      if (this.buttons.prev) {
+        this.appendButton(
+          this.buttons.prev,
+          () => {
+            this.collection.setOffset(this.iniOffset - this.pageSize);
+            this.collection.loadFromRemote();
+          },
+          this.iniOffset - this.pageSize
+        );
+      }
+    }
+    let lowerLimit = Math.floor(this.iniOffset / this.pageSize) - Math.floor(pagesToShow / 2);
+    lowerLimit = lowerLimit < 0 ? 0 : lowerLimit;
+    let upperLimit = Math.floor(this.iniOffset / this.pageSize) + Math.ceil(pagesToShow / 2);
+    upperLimit = upperLimit * this.pageSize < total ? upperLimit : Math.ceil(total / this.pageSize);
+    for (let i = lowerLimit; i < upperLimit; i++) {
+      if (!this.buttons.page) {
+        continue;
+      }
+      const pageOffset = i * this.pageSize;
+      const isActive = Math.floor(this.iniOffset / this.pageSize) === i;
+      let pageBtn = this.buttons.page.clone();
+      pageBtn.text(i + 1).attr("title", pageOffset).on("click", () => {
+        this.collection.setOffset(pageOffset);
+        this.collection.loadFromRemote();
+      });
+      if (isActive) {
+        pageBtn.addClass("active").off("click");
+      }
+      $(this.el).append(pageBtn);
+    }
+    const nxtOffset = this.iniOffset + this.pageSize;
+    if (this.iniOffset + this.pageSize < total) {
+      if (this.buttons.next) {
+        this.appendButton(
+          this.buttons.next,
+          () => {
+            this.collection.setOffset(nxtOffset);
+            this.collection.loadFromRemote();
+          },
+          nxtOffset
+        );
+      }
+      if (this.buttons.last) {
+        const lastPageOffset = (Math.ceil(total / this.pageSize) - 1) * this.pageSize;
+        log("last button", total, lastPageOffset, this.pageSize, this.offset);
+        if (lastPageOffset > this.iniOffset * 1) {
+          this.appendButton(
+            this.buttons.last,
+            () => {
+              this.collection.setOffset(lastPageOffset);
+              this.collection.loadFromRemote();
+            },
+            lastPageOffset
+          );
+        }
+      }
+    }
+    let offsetInp = $(this.collection.offsetinp);
+    if (offsetInp.length) {
+      offsetInp.val(this.iniOffset);
+    }
+  }
+  /**
+   * Destroy paging and clean up resources
+   */
+  destroy() {
+    if (this.collection && this.collection.pagesizeinp) {
+      const pageSizeInp = $(this.collection.pagesizeinp);
+      pageSizeInp.off("change");
+    }
+    if (this.collection && this.collection.offsetinp) {
+      const offsetInp = $(this.collection.offsetinp);
+      offsetInp.off("change");
+    }
+    if (this.el) {
+      const $el = $(this.el);
+      $el.empty();
+      $el.off();
+      $el.removeData();
+    }
+    this.collection = null;
+    this.el = null;
+    this.buttons = null;
+    this.$totalCount = null;
+    return this;
+  }
+};
+
+// src/Collection.js
+var Collection = class {
+  constructor(opts = {}) {
+    this.url = null;
+    this.deleteUrl = null;
+    this.insertUrl = null;
+    this.updateUrl = null;
+    this.paging = null;
+    this.view = null;
+    this.offset = 0;
+    this.total = null;
+    this.pageSize = 10;
+    this.template = null;
+    this.navtype = "page";
+    this.type = null;
+    this.emptyview = null;
+    this.items = [];
+    this.addontop = false;
+    this.uievents = [];
+    this.setAttrAsId = null;
+    this.itemListeners = null;
+    this.adapter = null;
+    this.callbacks = {};
+    this.iterator = -1;
+    trace("Collection init", opts);
+    try {
+      opts = parseOptions(opts);
+    } catch (e) {
+      throw new Error("Error on Collection init", e);
+    }
+    Object.defineProperty(this, "length", {
+      get() {
+        return this.items.length;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    let options = Object.assign({}, opts);
+    Object.assign(this, options);
+    if (options.hasOwnProperty("paging") && $(options.paging).length) {
+      this.paging = new Paging($(options.paging)[0], this);
+    }
+    if (this.url) {
+      this.setUrl(this.url);
+    }
+    if (this.deleteUrl) {
+      this.setUrl(this.deleteUrl, "delete");
+    }
+    if (this.updateUrl) {
+      this.setUrl(this.updateUrl, "update");
+    }
+    if (this.insertUrl) {
+      this.setUrl(this.insertUrl, "insert");
+    }
+    if (this.view) {
+      this.view.collection = this;
+    }
+    if (this.total) {
+      this.total = this.total * 1;
+    }
+    if (["page", "scroll"].indexOf(this.navtype) === -1) {
+      throw new Error("Invalid navigations type. Should be page or scroll");
+    }
+    this.adapter = resolveAdapter(opts.adapter);
+    this.storage = opts.hasOwnProperty("storage") ? opts.storage : new Storage(
+      (() => {
+        const storageOpts = Object.assign({}, opts.ajaxOpts || {});
+        if (opts.headers && typeof opts.headers === "object") {
+          storageOpts.headers = Object.assign(
+            {},
+            storageOpts.headers || {},
+            opts.headers
+          );
+        }
+        return storageOpts;
+      })()
+    );
+    if (typeof opts.listeners === "object") {
+      for (let event in opts.listeners) {
+        this.on(event, opts.listeners[event]);
+      }
+    }
+    if (opts.itemListeners && typeof opts.itemListeners === "object") {
+      this.itemListeners = opts.itemListeners;
+    } else if (opts.itemOn && typeof opts.itemOn === "object") {
+      this.itemListeners = opts.itemOn;
+    }
+  }
+  /**
+   * Event listener registration
+   */
+  on(eventName, cb) {
+    if (typeof this.callbacks[eventName] === "undefined") {
+      this.callbacks[eventName] = [];
+    }
+    this.callbacks[eventName].push(cb);
+    return this;
+  }
+  /**
+   * Remove event listener(s)
+   * @param {string} eventName - Event name
+   * @param {Function} [cb] - Optional callback to remove. If not provided, removes all listeners for the event
+   * @returns {Collection} This instance for chaining
+   */
+  off(eventName, cb) {
+    if (!eventName) {
+      this.callbacks = {};
+      return this;
+    }
+    if (!this.callbacks[eventName]) {
+      return this;
+    }
+    if (cb) {
+      const index = this.callbacks[eventName].indexOf(cb);
+      if (index > -1) {
+        this.callbacks[eventName].splice(index, 1);
+      }
+      if (this.callbacks[eventName].length === 0) {
+        delete this.callbacks[eventName];
+      }
+    } else {
+      delete this.callbacks[eventName];
+    }
+    return this;
+  }
+  /**
+   * Register a one-time event listener
+   * @param {string} eventName - Event name
+   * @param {Function} cb - Callback function
+   * @returns {Collection} This instance for chaining
+   */
+  once(eventName, cb) {
+    const wrapper = (...args) => {
+      cb(...args);
+      this.off(eventName, wrapper);
+    };
+    return this.on(eventName, wrapper);
+  }
+  /**
+   * Check if event has listeners
+   * @param {string} eventName - Event name
+   * @returns {boolean} True if event has listeners
+   */
+  hasListeners(eventName) {
+    return this.callbacks[eventName] && Array.isArray(this.callbacks[eventName]) && this.callbacks[eventName].length > 0;
+  }
+  /**
+   * Trigger an event (internal helper)
+   * @private
+   * @param {string} eventName - Event name
+   * @param {...any} args - Arguments to pass to callbacks
+   */
+  _trigger(eventName, ...args) {
+    if (this.callbacks[eventName] && Array.isArray(this.callbacks[eventName])) {
+      this.callbacks[eventName].forEach((cb) => {
+        if (typeof cb === "function") {
+          cb(...args);
+        }
+      });
+    }
+  }
+  /**
+   * Emit/trigger an event manually
+   * @param {string} eventName - Event name
+   * @param {...any} args - Arguments to pass to callbacks
+   * @returns {Collection} This instance for chaining
+   */
+  emit(eventName, ...args) {
+    this._trigger(eventName, ...args);
+    return this;
+  }
+  /**
+   * Show listeners (debug)
+   */
+  showlisteners() {
+    dbg(this.callbacks);
+  }
+  /**
+   * Remove item from collection
+   * 
+   * Removes item from items array. Does NOT trigger update event
+   * (that's handled by Item.remove() to avoid duplication).
+   * 
+   * @param {Item} item - Item instance to remove
+   * @returns {Promise} Resolves when item is removed
+   */
+  removeItem(item) {
+    const index = this.items.findIndex((i) => i === item || i.id && item.id && i.id === item.id);
+    if (index !== -1) {
+      this.items.splice(index, 1);
+    }
+    return Promise.resolve();
+  }
+  /**
+   * Set page size
+   */
+  setPageSize(val) {
+    if (/^\d+$/.test(val)) {
+      this.pageSize = val;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Empty collection
+   */
+  empty() {
+    return this.clear();
+  }
+  /**
+   * Set offset
+   */
+  setOffset(val) {
+    if (/^\d+$/.test(val)) {
+      this.offset = val;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Bulk update (not implemented)
+   */
+  update(data) {
+    throw new Error("Not implemented... yet");
+  }
+  setUrl(url, type) {
+    if (!url)
+      return this;
+    switch (type) {
+      case "delete":
+        this.deleteUrl = createURL(url);
+        break;
+      case "update":
+        this.updateUrl = createURL(url);
+        break;
+      case "insert":
+        this.insertUrl = createURL(url);
+        break;
+      default:
+        log("setUrl", url);
+        this.url = createURL(url);
+        this.deleteUrl = typeof this.deleteUrl == "string" ? createURL(this.deleteUrl) : this.deleteUrl ?? createURL(this.url);
+        this.updateUrl = typeof this.updateUrl == "string" ? createURL(this.updateUrl) : this.updateUrl ?? createURL(this.url);
+        this.insertUrl = typeof this.insertUrl == "string" ? createURL(this.insertUrl) : this.insertUrl ?? createURL(this.url);
+        break;
+    }
+    return this;
+  }
+  /**
+   * Receive remote data
+   * 
+   * Processes JSON:API document by hydrating relationships and extracting data array.
+   * Uses the new explicit hydration layer to replace relationship references with
+   * actual resource objects from included resources.
+   * 
+   * IMPORTANT: For single item responses (e.g., from append/create), uses parseItemData()
+   * to avoid wrapping in array and triggering collection replacement behavior.
+   */
+  receiveRemoteData(data) {
+    dbg("Remote data received", data);
+    if (this.adapter.isSingleItemResponse(data)) {
+      const hydratedItem = this.adapter.parseItemResponse(data);
+      this.adapter.applyMetadata(this, this.adapter.extractMetadata(data));
+      if (this.items.length === 0) {
+        this.view.reset(true);
+      }
+      dbg("Append single item to collection");
+      let newItem = this.loadItem(hydratedItem);
+      newItem.render(this.view, this.addontop);
+      this._trigger("afterrender", this);
+      return newItem;
+    }
+    const { items, meta } = this.adapter.parseCollectionResponse(data, { type: this.type });
+    this.adapter.applyMetadata(this, meta);
+    if (items == null) {
+      return;
+    }
+    if (items.constructor === Array) {
+      log("Append multiple items to collection");
+      if (this.items.length === 0) {
+        this.view.reset(true);
+      }
+      const loadedItems = [];
+      items.forEach((item) => {
+        const loadedItem = this.loadItem(item);
+        if (loadedItem) {
+          loadedItems.push(loadedItem);
+        }
+      });
+      this.render();
+      return loadedItems;
+    }
+  }
+  /**
+   * Extract metadata and data from JSON:API document
+   * 
+   * Extracts metadata (totalRecords, offset) from JSON:API response meta object
+   * and returns the hydrated data array. Data hydration is handled by
+   * parseCollectionData() before this is called.
+   * 
+   * @param {Object} data - JSON:API document (data property should already be hydrated)
+   * @returns {Array} Array of hydrated item data objects
+   */
+  extractMetadataAndData(data) {
+    dbg("extract metadata and data", data);
+    if (!data.hasOwnProperty("data")) {
+      return data;
+    }
+    this.adapter.applyMetadata(this, this.adapter.extractMetadata(data));
+    return data.data;
+  }
+  /**
+   * Parse collection data from JSON:API document (legacy alias)
+   * 
+   * @deprecated Use extractMetadataAndData() instead
+   * @param {Object} data - JSON:API document
+   * @returns {Array} Array of hydrated item data objects
+   */
+  parse(data) {
+    return this.extractMetadataAndData(data);
+  }
+  /**
+   * Load from data
+   */
+  loadFromData(data) {
+    dbg("collection load from data", data);
+    if (data === null || typeof data !== "object" || data.constructor !== Array) {
+      dbg("cannot load ", data, " into collection ", this);
+      return this;
+    }
+    if (this.navtype === "page") {
+      this.items = [];
+    }
+    data.forEach((item) => {
+      this.loadItem(item);
+    });
+    if (this.view) {
+      this.view.render();
+    } else {
+      dbg("collection does not have a view ", this);
+    }
+    this._trigger("load", this);
+    return this;
+  }
+  /**
+   * Next page
+   */
+  next() {
+    this.offset = parseInt(this.offset) + parseInt(this.pageSize);
+    this.loadFromRemote();
+  }
+  /**
+   * Previous page
+   */
+  prev() {
+    this.offset = parseInt(this.offset) - parseInt(this.pageSize);
+    this.loadFromRemote();
+  }
+  /**
+   * Clear collection
+   * 
+   * Synchronously clears items array and renders empty state.
+   * For async item cleanup, use destroy() instead.
+   * 
+   * @returns {Collection} This instance for chaining
+   */
+  clear() {
+    this.items = [];
+    if (this.view) {
+      this.view.render();
+    }
+    this._trigger("update", this);
+    return this;
+  }
+  /**
+   * Render collection
+   */
+  render() {
+    if (this.view) {
+      this.view.render();
+    }
+    this._trigger("afterrender", this);
+    return this;
+  }
+  /**
+   * Load from remote
+   * 
+   * Canonical method for loading collection data from API
+   */
+  loadFromRemote() {
+    return this.loadFromDataSource();
+  }
+  load(data) {
+    return data ? this.loadFromData(data) : this.loadFromRemote();
+  }
+  /**
+   * Load from data source (internal implementation)
+   * @private
+   */
+  loadFromDataSource() {
+    const overlay = createOverlay(this);
+    let loader = null;
+    if (this.view && this.view.el) {
+      loader = $(overlay).clone().insertBefore(this.view.el).width($(this.view.el).width()).height($(this.view.el).height());
+    }
+    this._trigger("beforeload", this);
+    return new Promise((resolve, reject) => {
+      if (!this.url) {
+        loader.remove();
+        reject(new Error("No valid URL provided"));
+        return;
+      }
+      this.adapter.applyListQuery(this.url, {
+        type: this.type,
+        offset: this.offset,
+        pageSize: this.pageSize
+      });
+      let urlString = this.url.toString ? this.url.toString() : this.url;
+      this.storage.read(this, urlString, {}).then((res) => {
+        if (this.navtype === "page") {
+          this.items = [];
+        }
+        this.receiveRemoteData(res.data);
+        this._trigger("load", this);
+        if (loader) {
+          $(loader).remove();
+        }
+        if (this.paging) {
+          this.paging.render();
+        }
+        resolve(this);
+      }).catch((error2) => {
+        if (error2 instanceof Error && error2.jqXHR) {
+          this.fail(error2.jqXHR, error2.textStatus || "error", error2.errorThrown || error2);
+          loader.remove();
+          reject(error2);
+        } else if (error2 && error2.jqXHR) {
+          this.fail(error2.jqXHR, error2.textStatus, error2.errorThrown);
+          loader.remove();
+          reject(error2);
+        } else {
+          this.fail(null, "error", error2);
+          loader.remove();
+          reject(error2);
+        }
+      });
+    });
+  }
+  /**
+   * Handle failure
+   */
+  fail(xhr, txt, err) {
+    dbg("Fail to load collection", xhr, txt, err, this);
+  }
+  /**
+   * On update callback
+   */
+  onupdate() {
+    console.log("onupdate");
+    this._trigger("update", this);
+    return this;
+  }
+  /**
+   * Insert a single new item into collection
+   * 
+   * Creates a single item via POST request and adds it to the collection.
+   * The server response should contain the created item in JSON:API format.
+   * 
+   * @param {Object} itemData - Single item data object (not an array)
+   * @returns {Promise<Item>} Promise resolving to the created Item instance
+   * @throws {Error} If itemData is an array (use batchInsert() instead)
+   */
+  insert(itemData) {
+    if (Array.isArray(itemData)) {
+      throw new Error("insert() expects a single item object. Use batchInsert() for multiple items.");
+    }
+    const payload = this.adapter.serializeForCreate(itemData, { type: this.type });
+    return new Promise((resolve, reject) => {
+      if (!this.insertUrl) {
+        this.insertUrl = this.url;
+      }
+      let insertUrlString = this.insertUrl.toString ? this.insertUrl.toString() : this.insertUrl;
+      this.storage.create(this, insertUrlString, { contentType: payload.contentType }, payload.body).then((resp) => {
+        let data = resp.data;
+        let newItem = this.receiveRemoteData(data);
+        log("newItem", newItem);
+        this.onupdate();
+        resolve(newItem);
+      }).catch((resp) => {
+        dbg("fail to receive data", resp);
+        reject(resp);
+      });
+    });
+  }
+  /**
+   * Batch insert multiple items into collection
+   * 
+   * Creates multiple items via POST request and adds them to the collection.
+   * The server response should contain an array of created items in JSON:API format.
+   * 
+   * @param {Array} itemsData - Array of item data objects
+   * @returns {Promise<Array<Item>>} Promise resolving to array of created Item instances
+   * @throws {Error} If itemsData is not an array
+   */
+  batchInsert(itemsData) {
+    if (!Array.isArray(itemsData)) {
+      throw new Error("batchInsert() expects an array of items. Use insert() for a single item.");
+    }
+    if (itemsData.length === 0) {
+      return Promise.resolve([]);
+    }
+    const payload = this.adapter.serializeForCreate(itemsData, { type: this.type });
+    return new Promise((resolve, reject) => {
+      if (!this.insertUrl) {
+        this.insertUrl = this.url;
+      }
+      let insertUrlString = this.insertUrl.toString ? this.insertUrl.toString() : this.insertUrl;
+      this.storage.create(this, insertUrlString, { contentType: payload.contentType }, payload.body).then((resp) => {
+        let data = resp.data;
+        const result = this.receiveRemoteData(data);
+        const newItems = Array.isArray(result) ? result : result ? [result] : [];
+        log("batchInsert newItems", newItems);
+        this.onupdate();
+        resolve(newItems);
+      }).catch((resp) => {
+        dbg("fail to receive batch data", resp);
+        reject(resp);
+      });
+    });
+  }
+  /**
+   * @deprecated Use insert() for single items or batchInsert() for multiple items
+   * This method is bivalent and will be removed in a future version.
+   * Alias for backward compatibility - delegates to insert() or batchInsert() based on input type.
+   */
+  append(itemData) {
+    if (Array.isArray(itemData)) {
+      return this.batchInsert(itemData);
+    } else {
+      return this.insert(itemData);
+    }
+  }
+  /**
+   * @deprecated Use insert() instead
+   * Alias for backward compatibility
+   */
+  createItem(itemData) {
+    return this.insert(itemData);
+  }
+  /**
+   * @deprecated Use insert() instead
+   * Alias for backward compatibility
+   */
+  newItem(itemData) {
+    return this.insert(itemData);
+  }
+  /**
+   * Load item
+   */
+  loadItem(itemData) {
+    log("loadItem from collection", itemData);
+    if (!itemData) {
+      log("no item data", itemData);
+      return null;
+    }
+    let opts = {
+      type: this.type,
+      collection: this,
+      uievents: this.uievents,
+      storage: this.storage,
+      adapter: this.adapter
+    };
+    if (this.setAttrAsId && itemData.id == null) {
+      log("set item id from attribute", this.setAttrAsId, itemData);
+      itemData.id = itemData.attributes[this.setAttrAsId];
+    }
+    if (itemData.id && this.url) {
+      let tmp;
+      const url = createURL(this.url.toString());
+      url.path += "/" + itemData.id;
+      opts.url = createURL(url.toString());
+      const updateUrl = createURL(this.updateUrl.toString());
+      updateUrl.path += "/" + itemData.id;
+      opts.updateUrl = createURL(updateUrl.toString());
+      const deleteUrl = createURL(this.deleteUrl.toString());
+      deleteUrl.path += "/" + itemData.id;
+      opts.deleteUrl = createURL(deleteUrl.toString());
+      const insertUrl = createURL(this.insertUrl.toString());
+      insertUrl.path += "/" + itemData.id;
+      opts.insertUrl = createURL(insertUrl.toString());
+    }
+    if (this.itemListeners) {
+      opts.itemListeners = this.itemListeners;
+    }
+    let newItem = new Item(opts).bindView(new ItemView({
+      template: this.template,
+      container: this.view
+    })).loadFromData(itemData);
+    if (this.addontop) {
+      dbg("Add on top");
+      this.items.unshift(newItem);
+    } else {
+      this.items.push(newItem);
+    }
+    return newItem;
+  }
+  /**
+   * Destroy collection and clean up resources
+   * 
+   * Removes event handlers, destroys all items and views, clears references.
+   * Safe to call multiple times.
+   * 
+   * @returns {Collection} This instance for chaining
+   */
+  destroy() {
+    const itemsToDestroy = [...this.items];
+    itemsToDestroy.forEach((item) => {
+      if (item && typeof item.destroy === "function") {
+        item.destroy();
+      }
+    });
+    this.items = [];
+    if (this.view && typeof this.view.destroy === "function") {
+      this.view.destroy();
+    }
+    this.view = null;
+    if (this.filtering && typeof this.filtering.destroy === "function") {
+      this.filtering.destroy();
+    }
+    this.filtering = null;
+    if (this.paging && typeof this.paging.destroy === "function") {
+      this.paging.destroy();
+    }
+    this.paging = null;
+    this.callbacks = {};
+    this.storage = null;
+    this.url = null;
+    this.deleteUrl = null;
+    this.insertUrl = null;
+    this.updateUrl = null;
+    this.items = [];
+    this.total = null;
+    this.offset = 0;
+    return this;
+  }
+};
+
+// src/Filtering.js
+var Filtering = class {
+  constructor(filterForm, collection) {
+    this.collection = collection;
+    this.el = filterForm;
+    let $form = $(filterForm);
+    $form.data("instance", collection).on("submit", (e) => {
+      dbg("Filter form was submitted");
+      e.preventDefault();
+      this.handleSubmit($form[0]);
+    }).on("reset", () => {
+      delete this.collection.url.parameters.filter;
+      this.collection.loadFromRemote();
+      dbg("filter form reset");
+    });
+  }
+  /**
+   * Handle form submit
+   */
+  handleSubmit(form) {
+    let filter = [];
+    for (let i = 0; i < form.elements.length; i++) {
+      let el = form.elements[i];
+      let $el = $(el);
+      let value = $el.val();
+      let operator = $el.data("operator");
+      if (el.name && value) {
+        filter.push(
+          el.name + (operator ? operator : "=") + value
+        );
+      }
+    }
+    this.collection.offset = 0;
+    if (filter.length) {
+      this.collection.url.parameters.filter = filter.join(",");
+    } else {
+      delete this.collection.url.parameters.filter;
+    }
+    this.collection.loadFromRemote();
+  }
+  /**
+   * Destroy filtering and clean up resources
+   */
+  destroy() {
+    if (this.el) {
+      const $form = $(this.el);
+      $form.off("submit");
+      $form.off("reset");
+      if (typeof $form.removeData === "function") {
+        $form.removeData("instance");
+      }
+    }
+    this.collection = null;
+    this.el = null;
+    return this;
+  }
+};
+
+// src/Sorting.js
+var Sorting = class {
+  constructor(sortHeader, collection) {
+    this.el = sortHeader;
+    this.collection = collection;
+    const $sorts = sortHeader.find("[data-sortfld]").data("instance", this.collection).on("click", this.sortNow.bind(this));
+  }
+  sortNow(ev) {
+    let $lnk = $(ev.currentTarget);
+    let fld = $lnk.data("sortfld");
+    let dir = $lnk.data("sortdir");
+    let inst = this.collection;
+    let sort = inst.url.parameters.hasOwnProperty("sort") ? inst.url.parameters.sort : "";
+    let sortArr = [];
+    sort.split(",").forEach(function(item) {
+      let res = /^(-*)([a-z0-9\-\_]+)$/.exec(item.trim());
+      if (!res)
+        return;
+      if (res[2] == fld)
+        return;
+      sortArr.push(item);
+    });
+    switch (dir) {
+      case "up":
+        sortArr.push("-" + fld);
+        $lnk.data("sortdir", "down");
+        $lnk.find(".sort-up").hide();
+        $lnk.find(".sort-down").show();
+        $lnk.find(".sort-default").hide();
+        break;
+      case "down":
+        $lnk.data("sortdir", null);
+        $lnk.find(".sort-up").hide();
+        $lnk.find(".sort-down").hide();
+        $lnk.find(".sort-default").show();
+        break;
+      default:
+        $lnk.data("sortdir", "up");
+        sortArr.push(fld);
+        $lnk.find(".sort-up").show();
+        $lnk.find(".sort-down").hide();
+        $lnk.find(".sort-default").hide();
+    }
+    let nxtSort = sortArr.join(",");
+    if (sort !== nxtSort) {
+      inst.url.parameters.sort = nxtSort;
+      inst.loadFromRemote();
+    }
+  }
+  destroy() {
+    if (this.el) {
+      $(this.el).find("[data-sortfld]").each(function(sort) {
+        $(this).off("click");
+        $(this).removeData("instance");
+      });
+    }
+    return this;
+  }
+};
+
+// src/utilities.js
+var utilities = {
+  /**
+   * Fill form fields with data from instance
+   */
+  fillForm: function(form, instance) {
+    let formEl = $(form)[0];
+    if ($(form).prop("tagName") !== "FORM") {
+      return null;
+    }
+    if (!instance || !instance.hasOwnProperty("attributes")) {
+      return null;
+    }
+    Object.getOwnPropertyNames(instance.attributes).forEach((attrName) => {
+      if (!formEl.elements.hasOwnProperty(attrName)) {
+        return;
+      }
+      let val = instance.attributes[attrName];
+      let inp = formEl.elements[attrName];
+      let $inp = $(inp);
+      if (instance.attributes[attrName] && typeof instance.attributes[attrName] === "object" && instance.attributes[attrName].hasOwnProperty("id")) {
+        val = instance.attributes[attrName].id;
+      }
+      if ($inp.attr("type") === "date") {
+        val = val ? val.substr(0, 10) : val;
+      }
+      $inp.val(val);
+    });
+    if (!instance.relationships) {
+      return;
+    }
+    Object.getOwnPropertyNames(instance.relationships).forEach((relName) => {
+      if (!formEl.elements.hasOwnProperty(relName)) {
+        return;
+      }
+      if (!instance.relationships[relName]) {
+        $(formEl.elements[relName]).val(null);
+        return;
+      }
+      let rel = instance.relationships[relName];
+      let formElRel = formEl.elements[relName];
+      if (rel.constructor === Array) {
+        let vals = [];
+        rel.forEach((relItem) => {
+          vals.push(relItem.id);
+        });
+        $(formElRel).val(vals);
+      } else {
+        dbg("set ", relName, rel);
+        if (formElRel.tagName === "SELECT") {
+          let lbl = $(formElRel).data("label");
+          let lblVal = rel.hasOwnProperty("attributes") && rel.attributes[lbl] ? rel.attributes[lbl] : rel.id;
+          $("<option>").val(rel.id).text(lblVal).appendTo($(formElRel));
+        }
+        $(formElRel).val(rel.id);
+      }
+    });
+  },
+  /**
+   * Capture form submit event and redirect it to callback
+   */
+  captureFormSubmit: function(form, cb) {
+    let formEl = $(form);
+    if (formEl.prop("tagName") !== "FORM" || typeof cb !== "function") {
+      return;
+    }
+    formEl.off("submit").on("submit", (event) => {
+      event.preventDefault();
+      let frm = formEl[0];
+      cb(this.fetchFormData(frm), event);
+    });
+    return formEl;
+  },
+  /**
+   * Fetch form data - handles array notation (name[]) and normalizes form element
+   */
+  fetchFormData: function(form) {
+    let formEl = $(form)[0];
+    let formElements = {};
+    Object.getOwnPropertyNames(formEl.elements).forEach((item) => {
+      let el = formEl.elements[item];
+      let $item = $(el);
+      if (!$item.attr("name") || $item.attr("name") === "") {
+        return;
+      }
+      if ($item.attr("type") === "checkbox" && !$item[0].checked) {
+        return;
+      }
+      let name = $item.attr("name");
+      let value = $item.val();
+      let arrayMatch = /(\w+)\[\]/.exec(name);
+      if (arrayMatch) {
+        let arrayName = arrayMatch[1];
+        if (!formElements[arrayName]) {
+          formElements[arrayName] = [];
+        }
+        formElements[arrayName].push(value);
+      } else {
+        formElements[name] = value;
+      }
+    });
+    return formElements;
+  },
+  /**
+   * Extract form data - alias for fetchFormData (for backward compatibility)
+   */
+  extractFormData: function(form) {
+    return this.fetchFormData(form);
+  }
+};
+
+// src/KViews.js
+var KViews = class _KViews {
+  /**
+   * Helper: Extract and merge options from element and parameters
+   */
+  static prepareOptions(el, opts) {
+    if (!el) {
+      dbg("Warning: no DOM element provided for apiator");
+      return null;
+    }
+    if (typeof opts === "string") {
+      opts = {
+        url: opts
+      };
+    }
+    let options = { dataBindings: {}, addontop: false };
+    options = Object.assign(options, $(el).data());
+    try {
+      Object.assign(options, parseOptions(opts));
+    } catch (e) {
+      throw new Error("Error on KViews init", e);
+    }
+    return options;
+  }
+  /**
+   * Helper: Check for existing instance and update if found
+   * 
+   * SAFE UPDATE CONTRACT:
+   * Only updates whitelisted safe configuration options.
+   * Does not overwrite internal runtime state (callbacks, items, views, etc.)
+   * 
+   * Safe to update:
+   * - url, updateUrl, deleteUrl, insertUrl (via setUrl)
+   * - template, type, pageSize, offset (configuration)
+   * - emptyview, filter, paging (view configuration)
+   * 
+   * NOT updated (internal state):
+   * - callbacks, items, views, storage, filtering, paging instances
+   * - length, total, iterator (runtime state)
+   */
+  static getOrUpdateInstance(el, options) {
+    let existingInstance = $(el).data("instance");
+    if (existingInstance !== void 0) {
+      const safeUpdateOptions = [
+        "url",
+        "updateUrl",
+        "deleteUrl",
+        "insertUrl",
+        "template",
+        "type",
+        "pageSize",
+        "offset",
+        "emptyview",
+        "filter",
+        "paging",
+        "addontop",
+        "uievents",
+        "setAttrAsId",
+        "itemListeners",
+        "itemOn",
+        "headers",
+        "adapter"
+      ];
+      if (options.url) {
+        existingInstance.setUrl(options.url);
+        delete options.url;
+      }
+      const parsedOptions = parseOptions(options);
+      const safeUpdates = {};
+      safeUpdateOptions.forEach((key) => {
+        if (parsedOptions.hasOwnProperty(key)) {
+          safeUpdates[key] = parsedOptions[key];
+        }
+      });
+      Object.assign(existingInstance, safeUpdates);
+      if (safeUpdates.adapter) {
+        existingInstance.adapter = resolveAdapter(safeUpdates.adapter);
+      }
+      if (safeUpdates.headers && existingInstance.storage && existingInstance.storage.defaultOptions) {
+        existingInstance.storage.defaultOptions.headers = Object.assign(
+          {},
+          existingInstance.storage.defaultOptions.headers || {},
+          safeUpdates.headers
+        );
+      }
+      return existingInstance;
+    }
+    return null;
+  }
+  /**
+   * Helper: Handle emptyview option
+   */
+  static processEmptyView(options) {
+    if (options.hasOwnProperty("emptyview")) {
+      options.emptyview = $(options.emptyview).remove();
+    }
+  }
+  /**
+   * Helper: Attach listeners and finalize instance
+   */
+  static finalizeInstance(el, instance, options, listeners) {
+    if (listeners) {
+      Object.getOwnPropertyNames(listeners).forEach((eventName) => {
+        instance.on(eventName, listeners[eventName]);
+      });
+    }
+    $(el).data("instance", instance);
+    dbg("instance", instance.url);
+    if (instance.url && (typeof options.dontload === "undefined" || !options.dontload)) {
+      log("loadFromRemote now", options, instance);
+      instance.loadFromRemote();
+    }
+    return instance;
+  }
+  /**
+   * Create collection instance
+   */
+  static createCollectionInstance(el, opts) {
+    let options = _KViews.prepareOptions(el, opts);
+    log("createCollectionInstance", options);
+    if (!options) {
+      return null;
+    }
+    let existingInstance = _KViews.getOrUpdateInstance(el, options);
+    if (existingInstance) {
+      return existingInstance;
+    }
+    dbg("init apiator collection on ", el, options);
+    _KViews.processEmptyView(options);
+    let listeners = options.on;
+    delete options.on;
+    dbg("Create collection instance", options);
+    let templateTxt = $(el).length ? $(el).html() : null;
+    if (options.template) {
+      if (options.template instanceof jQuery) {
+        dbg("template is jQuery object", options.template, el);
+        let $tpl = $(options.template).clone().removeAttr("id");
+        templateTxt = $("<div>").append($tpl).html();
+      } else if (typeof options.template === "string") {
+        dbg("template is raw text: can be either a jQuery selector or raw HTML", options.template, el);
+        templateTxt = $("<div>").append($(options.template).clone().removeAttr("id")).html();
+      }
+    }
+    if (templateTxt !== null) {
+      templateTxt = templateTxt.replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&apos;/gi, "'").replace(/&quot;/gi, '"').replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&");
+      options.template = template(templateTxt);
+    }
+    let collectionConfig = {
+      el,
+      itemsContainer: options.hasOwnProperty("container") ? $(options.container) : el,
+      allowempty: options.disableempty !== true
+    };
+    options.view = new CollectionView(collectionConfig);
+    log("Collection constructor", options);
+    let instance = new Collection(options);
+    if (options.hasOwnProperty("filter")) {
+      let filterEl = $(options.filter);
+      if (filterEl.length && filterEl.prop("tagName") === "FORM") {
+        instance.filtering = new Filtering(filterEl, instance);
+      }
+    }
+    if (options.hasOwnProperty("sort")) {
+      log("setup sorting", options.sort);
+      let sortEl = $(options.sort);
+      if (sortEl.length) {
+        instance.sorting = new Sorting(sortEl, instance);
+      }
+    }
+    _KViews.finalizeInstance(el, instance, options, listeners);
+    return instance;
+  }
+  /**
+   * Create item instance
+   */
+  static createItemInstance(el, opts, data = null) {
+    let options = _KViews.prepareOptions(el, opts);
+    if (!options) {
+      return null;
+    }
+    let existingInstance = _KViews.getOrUpdateInstance(el, options);
+    if (existingInstance) {
+      return existingInstance;
+    }
+    dbg("init apiator item on ", el, options);
+    _KViews.processEmptyView(options);
+    let listeners = options.on;
+    delete options.on;
+    options.template = null;
+    let templateTxt = null;
+    if ($(el).length) {
+      var node = $(el)[0];
+      templateTxt = node ? node.outerHTML : null;
+    }
+    if (templateTxt) {
+      templateTxt = templateTxt.replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&apos;/gi, "'").replace(/&quot;/gi, '"').replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&");
+      options.template = template(templateTxt);
+    }
+    let elId = $(el).attr("id");
+    let instance = new Item(options, data).bindView(new ItemView({
+      template: options.template,
+      el,
+      id: elId ? elId : null
+    }));
+    _KViews.finalizeInstance(el, instance, options, listeners);
+    if (options.dontload && instance.attributes && Object.keys(instance.attributes).length > 0) {
+      instance.render();
+    }
+    return instance;
+  }
+  static helpers = utilities;
+  /**
+   * Global default data adapter (name or instance). Defaults to 'jsonapi'.
+   */
+  static get defaultAdapter() {
+    return getDefaultAdapter();
+  }
+  static set defaultAdapter(adapter) {
+    setDefaultAdapter(adapter);
+  }
+  /**
+   * Register a custom data adapter by name.
+   *
+   * @param {string} name
+   * @param {object} adapter
+   */
+  static registerAdapter(name, adapter) {
+    registerAdapter(name, adapter);
+  }
+};
+Object.defineProperty(KViews, "baseUrl", {
+  enumerable: true,
+  configurable: true,
+  get() {
+    return apiBaseConfig.baseUrl;
+  },
+  set(v) {
+    apiBaseConfig.baseUrl = v;
+  }
+});
+Object.defineProperty(KViews, "basePath", {
+  enumerable: true,
+  configurable: true,
+  get() {
+    return apiBaseConfig.basePath;
+  },
+  set(v) {
+    apiBaseConfig.basePath = v;
+  }
+});
+Object.defineProperty(KViews, "defaultHeaders", {
+  enumerable: true,
+  configurable: true,
+  get() {
+    return apiBaseConfig.defaultHeaders;
+  },
+  set(v) {
+    if (v && typeof v === "object" && !Array.isArray(v)) {
+      apiBaseConfig.defaultHeaders = v;
+    } else {
+      apiBaseConfig.defaultHeaders = {};
+    }
+  }
+});
+
+// src/index.js
+var index_default = KViews;
+if (typeof window !== "undefined") {
+  window.KViews = KViews;
+}
+if (typeof $ !== "undefined" && $.fn) {
+  $.fn.kviews = function(opts) {
+    let el = this.length ? this[0] : this;
+    let resourcetype = "collection";
+    if (opts && opts.resourcetype) {
+      resourcetype = opts.resourcetype;
+    } else {
+      let dataResourcetype = $(el).data("resourcetype");
+      if (dataResourcetype) {
+        resourcetype = dataResourcetype;
+      }
+    }
+    if (resourcetype === "item") {
+      return KViews.createItemInstance(el, opts);
+    } else {
+      return KViews.createCollectionInstance(el, opts);
+    }
+  };
+  Object.defineProperty($.fn.kviews, "baseUrl", {
+    enumerable: true,
+    configurable: true,
+    get() {
+      return apiBaseConfig.baseUrl;
+    },
+    set(v) {
+      apiBaseConfig.baseUrl = v;
+    }
+  });
+  Object.defineProperty($.fn.kviews, "basePath", {
+    enumerable: true,
+    configurable: true,
+    get() {
+      return apiBaseConfig.basePath;
+    },
+    set(v) {
+      apiBaseConfig.basePath = v;
+    }
+  });
+  Object.defineProperty($.fn.kviews, "defaultHeaders", {
+    enumerable: true,
+    configurable: true,
+    get() {
+      return apiBaseConfig.defaultHeaders;
+    },
+    set(v) {
+      if (v && typeof v === "object" && !Array.isArray(v)) {
+        apiBaseConfig.defaultHeaders = v;
+      } else {
+        apiBaseConfig.defaultHeaders = {};
+      }
+    }
+  });
+  $.fn.kviewsCollection = function(opts) {
+    let options = {
+      resourcetype: "collection"
+    };
+    if (typeof opts === "undefined") {
+      opts = {};
+    }
+    if (typeof opts === "string") {
+      opts = {
+        url: opts
+      };
+    }
+    opts = Object.assign(opts, options);
+    return this.kviews(opts);
+  };
+  $.fn.kviewsItem = function(opts) {
+    let options = {
+      resourcetype: "item"
+    };
+    if (typeof opts === "undefined") {
+      opts = {};
+    }
+    if (typeof opts === "string") {
+      opts = {
+        url: opts
+      };
+    }
+    opts = Object.assign(opts, options);
+    return this.kviews(opts);
+  };
+}
+export {
+  Collection,
+  CollectionView,
+  Filtering,
+  Item,
+  ItemView,
+  JsonApiAdapter,
+  KViews,
+  Paging,
+  PlainRestAdapter,
+  Sorting,
+  Storage,
+  URL,
+  createOverlay,
+  createURL,
+  dbg,
+  deepmerge,
+  index_default as default,
+  error,
+  getBoundObjects,
+  getDefaultAdapter,
+  log,
+  parseOptions,
+  registerAdapter,
+  resolveAdapter,
+  setDefaultAdapter,
+  template,
+  trace,
+  uid,
+  utilities
+};
+//# sourceMappingURL=index.js.map