@archbase/data 3.0.0

package/dist/index.js

@@ -0,0 +1,3360 @@
+import { isDate as we, parseISO as Ee } from "date-fns";
+import { EventEmitter as Le } from "events";
+import { uniqueId as Be, cloneDeep as $e } from "lodash";
+import { archbaseI18next as m, ArchbaseDataSourceError as g, ArchbaseObjectHelper as ye, processErrorMessage as k, QUICK as Se, NORMAL as Fe, ADVANCED as Ae, ArchbaseFilterDSL as xe, QueryFilterEntity as ue, detectDataSourceVersion as ve, MigrationMetrics as Ne, ARCHBASE_IOC_API_TYPE as He, ArchbaseJacksonParser as ie } from "@archbase/core";
+import { ADVANCED as Mt, ARCHBASE_IOC_API_TYPE as jt, FILTER_TYPE as Ut, NORMAL as Gt, QUICK as kt, useArchbaseBool as qt } from "@archbase/core";
+import { useState as C, useCallback as l, useRef as le, useMemo as H, useEffect as J, useReducer as We } from "react";
+import { produce as _ } from "immer";
+import "reflect-metadata";
+import ee from "axios";
+import * as ne from "inversify";
+import { useContainer as ze } from "inversify-react";
+import { create as Me } from "zustand";
+import { createTrackedSelector as je } from "react-tracked";
+var d = /* @__PURE__ */ ((n) => (n[n.dataChanged = 0] = "dataChanged", n[n.recordChanged = 1] = "recordChanged", n[n.refreshData = 2] = "refreshData", n[n.fieldChanged = 3] = "fieldChanged", n[n.beforeClose = 4] = "beforeClose", n[n.afterClose = 5] = "afterClose", n[n.beforeOpen = 6] = "beforeOpen", n[n.afterOpen = 7] = "afterOpen", n[n.beforeAppend = 8] = "beforeAppend", n[n.afterAppend = 9] = "afterAppend", n[n.beforeRemove = 10] = "beforeRemove", n[n.afterRemove = 11] = "afterRemove", n[n.beforeInsert = 12] = "beforeInsert", n[n.afterInsert = 13] = "afterInsert", n[n.beforeEdit = 14] = "beforeEdit", n[n.afterEdit = 15] = "afterEdit", n[n.beforeSave = 16] = "beforeSave", n[n.afterSave = 17] = "afterSave", n[n.beforeCancel = 18] = "beforeCancel", n[n.afterCancel = 19] = "afterCancel", n[n.afterScroll = 20] = "afterScroll", n[n.onError = 21] = "onError", n[n.onFieldError = 22] = "onFieldError", n))(d || {});
+class Ue {
+  eventEmitter;
+  listenersDisable = !1;
+  constructor() {
+    this.eventEmitter = new Le();
+  }
+  disabledAllListeners() {
+    return this.listenersDisable = !0, this;
+  }
+  enableAllListeners() {
+    return this.listenersDisable = !1, this;
+  }
+  emit(e, ...t) {
+    return this.listenersDisable ? !1 : this.eventEmitter.emit(e, t);
+  }
+  addListener(e, t) {
+    return this.eventEmitter.addListener(e, t), this;
+  }
+  on(e, t) {
+    return this.eventEmitter.on(e, t), this;
+  }
+  once(e, t) {
+    return this.eventEmitter.once(e, t), this;
+  }
+  removeListener(e, t) {
+    return this.eventEmitter.removeListener(e, t), this;
+  }
+  off(e, t) {
+    return this.eventEmitter.off(e, t), this;
+  }
+  removeAllListeners(e) {
+    return this.eventEmitter.removeAllListeners(e), this;
+  }
+}
+class Ie {
+  fieldEventListeners;
+  records;
+  filteredRecords;
+  filters;
+  grandTotalRecords = 0;
+  currentPageIndex = 0;
+  totalPages = 0;
+  pageSize = 0;
+  currentRecordIndex = -1;
+  currentRecord;
+  oldRecord;
+  oldRecordIndex = -1;
+  emitter;
+  listeners = /* @__PURE__ */ new Set();
+  listenersDisable = !1;
+  inserting = !1;
+  active = !1;
+  editing = !1;
+  name;
+  label;
+  uuid;
+  lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime();
+  lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime();
+  filter;
+  sort;
+  originFilter;
+  originSort;
+  originGlobalFilter;
+  defaultSortFields = [];
+  validator;
+  getIdentity;
+  constructor(e, t, r) {
+    this.name = e, this.label = r || e, this.records = [], this.filteredRecords = [], this.loadOptions(t), this.fieldEventListeners = {}, this.emitter = new Ue(), this.uuid = Be(), this.validator = t.validator, this.getIdentity = t.getIdentity;
+  }
+  loadOptions(e) {
+    this.records = e.records, this.filters = [], e.filters && (this.filters = e.filters), this.currentRecord = void 0, this.currentRecordIndex = -1, this.filteredRecords = this.applyFilters(), this.filteredRecords.length > 0 && (this.currentRecordIndex = 0, this.currentRecord = this.filteredRecords[this.currentRecordIndex]), this.grandTotalRecords = e.grandTotalRecords, this.currentPageIndex = e.currentPage, this.totalPages = e.totalPages, this.pageSize = e.pageSize, this.active = !0, this.filter = e.filter, this.sort = e.sort, this.originFilter = e.originFilter, this.originSort = e.originSort, this.originGlobalFilter = e.originGlobalFilter, this.defaultSortFields = e.defaultSortFields ? e.defaultSortFields : [];
+  }
+  validateDataSourceActive(e) {
+    if (!this.isActive()) {
+      const t = m.t("archbase:operationNotAllowed", { dataSourceName: this.name, operation: e });
+      throw this.publishEventError(t, {}), new g(t);
+    }
+  }
+  getName() {
+    return this.name;
+  }
+  /**
+   * Limpa os dados do DataSource. Ao usar este método os seguintes eventos serão gerados:
+   * beforeClose, afterOpen, dataChanged, afterScroll
+   */
+  clear() {
+    if (!this.isActive()) {
+      const e = m.t("archbase:operationNotAllowed", { dataSourceName: this.name, operation: "clear" });
+      throw this.publishEventError(e, {}), new g(e);
+    }
+    this.emitter.emit("beforeClose"), this.emit({
+      type: 4
+      /* beforeClose */
+    }), this.loadOptions({
+      records: [],
+      totalPages: 0,
+      grandTotalRecords: 0,
+      currentPage: 0,
+      pageSize: 0
+    }), this.active = !0, this.editing = !1, this.inserting = !1, this.emitter.emit("afterOpen"), this.emit({
+      type: 7
+      /* afterOpen */
+    }), this.emitter.emit("dataChanged", this.records), this.emit({ type: 0, data: this.records }), this.emitter.emit("afterScroll"), this.emit({
+      type: 20
+      /* afterScroll */
+    }), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime(), this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime();
+  }
+  open(e) {
+    this.active = !1, this.emitter.emit("beforeClose"), this.emit({
+      type: 4
+      /* beforeClose */
+    }), this.loadOptions(e), this.active = !0, this.emitter.emit("afterOpen"), this.emit({
+      type: 7
+      /* afterOpen */
+    }), this.emitter.emit("dataChanged", this.records), this.emit({ type: 0, data: this.records }), this.emitter.emit("afterScroll"), this.emit({
+      type: 20
+      /* afterScroll */
+    }), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime(), this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime();
+  }
+  close() {
+    this.validateDataSourceActive("close"), this.emitter.emit("beforeClose"), this.emit({
+      type: 4
+      /* beforeClose */
+    }), this.active = !1, this.emitter.emit("afterClose"), this.emit({
+      type: 5
+      /* afterClose */
+    }), this.emitter.emit("afterScroll"), this.emit({
+      type: 20
+      /* afterScroll */
+    }), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime(), this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime();
+  }
+  setData(e) {
+    this.validateDataSourceActive("setData"), this.loadOptions(e), this.emitter.emit("dataChanged", this.records), this.emit({ type: 0, data: this.records }), this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime();
+  }
+  goToPage(e) {
+    return this.validateDataSourceActive("goToPage"), this;
+  }
+  goToRecord(e) {
+    if (this.validateDataSourceActive("goToRecord"), this.inserting || this.editing || this.isBOF() || this.isEOF()) {
+      const t = m.t("archbase:notAllowedBrowseRecords", { dataSourceName: this.name });
+      throw this.publishEventError(t, {}), new g(t);
+    }
+    e <= this.getTotalRecords() - 1 && (this.currentRecordIndex = e, this.emitter.emit("afterScroll"), this.emit({
+      type: 20
+      /* afterScroll */
+    }), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime());
+  }
+  disabledAllListeners() {
+    return this.listenersDisable = !0, this.emitter.disabledAllListeners(), this;
+  }
+  enableAllListeners() {
+    return this.listenersDisable = !1, this.emitter.enableAllListeners(), this;
+  }
+  addFilter(e) {
+    return this.filters?.push(e), this;
+  }
+  removeFilter(e) {
+    const t = this.filters?.indexOf(e);
+    return t && t >= 0 && this.filters?.splice(t, 1), this;
+  }
+  clearFilters() {
+    return this.filters = [], this;
+  }
+  applyFilters() {
+    if (!this.filters || this.filters.length === 0)
+      return this.records;
+    let e = [...this.records];
+    return this.filters?.forEach((t) => {
+      e = e.filter(t);
+    }), e;
+  }
+  emit(e) {
+    if (!this.listenersDisable)
+      for (const t of this.listeners)
+        t(e);
+  }
+  append(e) {
+    if (this.validateDataSourceActive("append"), this.inserting || this.editing) {
+      const t = m.t("archbase:insertRecordIsNotAllowed", { dataSourceName: this.name });
+      throw this.publishEventError(t, {}), new g(t);
+    }
+    return this.emitter.emit("beforeAppend", e), this.emit({ type: 8, record: e }), this.records.push(e), this.filteredRecords = this.applyFilters(), this.grandTotalRecords++, this.filteredRecords.forEach((t, r) => {
+      e === t && (this.currentRecordIndex = r, this.currentRecord = this.filteredRecords[this.currentRecordIndex], this.emitter.emit("afterScroll"), this.emit({
+        type: 20
+        /* afterScroll */
+      }), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime());
+    }), this.emitter.emit("afterAppend", e, this.currentRecordIndex), this.emit({
+      type: 9,
+      record: e,
+      index: this.currentRecordIndex
+    }), this.emitter.emit("afterScroll"), this.emit({
+      type: 20
+      /* afterScroll */
+    }), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime(), this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime(), this.currentRecordIndex;
+  }
+  insert(e) {
+    if (this.validateDataSourceActive("insert"), this.inserting || this.editing) {
+      const r = m.t("archbase:insertRecordIsNotAllowed", { dataSourceName: this.name });
+      throw this.publishEventError(r, {}), new g(r);
+    }
+    this.emitter.emit("beforeInsert"), this.emit({
+      type: 12
+      /* beforeInsert */
+    }), this.oldRecord = this.getCurrentRecord(), this.oldRecordIndex = this.currentRecordIndex, this.grandTotalRecords++;
+    const t = this.getTotalRecords();
+    return this.filteredRecords = [...this.filteredRecords, e], this.currentRecordIndex = t, this.currentRecord = e, this.inserting = !0, this.emitter.emit("afterInsert", e, this.currentRecordIndex), this.emit({
+      type: 13,
+      record: e,
+      index: this.currentRecordIndex
+    }), this.emitter.emit("afterScroll"), this.emit({
+      type: 20
+      /* afterScroll */
+    }), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime(), this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime(), this;
+  }
+  edit() {
+    if (this.validateDataSourceActive("edit"), this.inserting || this.editing) {
+      const e = m.t("archbase:editRecordIsNotAllowed", { dataSourceName: this.name });
+      throw this.publishEventError(e, {}), new g(e);
+    }
+    if (this.isEmpty() || !this.currentRecord) {
+      const e = m.t("archbase:noRecordsToEdit", { dataSourceName: this.name });
+      throw this.publishEventError(e, {}), new g(e);
+    }
+    if (this.isBOF()) {
+      const e = m.t("archbase:BOFDataSource", { dataSourceName: this.name });
+      throw this.publishEventError(e, {}), new g(e);
+    }
+    if (this.isEOF()) {
+      const e = m.t("archbase:EOFDataSource", { dataSourceName: this.name });
+      throw this.publishEventError(e, {}), new g(e);
+    }
+    return this.emitter.emit("beforeEdit", this.currentRecord, this.currentRecordIndex), this.emit({
+      type: 14,
+      record: this.currentRecord,
+      index: this.getCurrentIndex()
+    }), this.editing = !0, this.currentRecord = $e(this.currentRecord), this.emitter.emit("afterEdit", this.currentRecord, this.getCurrentIndex()), this.emit({
+      type: 15,
+      record: this.currentRecord,
+      index: this.getCurrentIndex()
+    }), this;
+  }
+  async remove(e) {
+    if (this.validateDataSourceActive("remove"), this.inserting || this.editing) {
+      const s = m.t("archbase:removingRecordIsNotAllowed", { dataSourceName: this.name });
+      throw this.publishEventError(s, {}), new g(s);
+    }
+    if (this.isEmpty() || !this.currentRecord) {
+      const s = m.t("archbase:noRecordsToEdit", { dataSourceName: this.name });
+      throw this.publishEventError(s, {}), new g(s);
+    }
+    if (this.isBOF()) {
+      const s = m.t("archbase:BOFDataSource", { dataSourceName: this.name });
+      throw this.publishEventError(s, {}), new g(s);
+    }
+    if (this.isEOF()) {
+      const s = m.t("archbase:EOFDataSource", { dataSourceName: this.name });
+      throw this.publishEventError(s, {}), new g(s);
+    }
+    this.emitter.emit("beforeRemove", this.currentRecord, this.currentRecordIndex), this.emit({
+      type: 10,
+      record: this.currentRecord,
+      index: this.getCurrentIndex()
+    });
+    let t = -1;
+    const r = this.currentRecord, i = this.currentRecordIndex;
+    return this.records.forEach((s, o) => {
+      this.currentRecord === s && (t = o);
+    }), t >= 0 && this.records.splice(t, 1), this.records !== this.filteredRecords && this.filteredRecords.splice(this.getCurrentIndex(), 1), this.grandTotalRecords--, this.filteredRecords.length === 0 ? (this.currentRecord = void 0, this.currentRecordIndex = -1) : (this.currentRecordIndex > this.filteredRecords.length - 1 && this.currentRecordIndex--, this.currentRecord = this.filteredRecords[this.currentRecordIndex]), this.editing = !1, this.inserting = !1, this.emitter.emit("afterScroll"), this.emit({
+      type: 20
+      /* afterScroll */
+    }), this.emitter.emit("afterRemove", r, i), this.emit({
+      type: 11,
+      record: r,
+      index: i
+    }), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime(), this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime(), e && e(), r;
+  }
+  isBrowsing() {
+    return !this.isEditing() && !this.isInserting() && this.isActive();
+  }
+  isEditing() {
+    return this.editing;
+  }
+  isInserting() {
+    return this.inserting;
+  }
+  isActive() {
+    return this.active;
+  }
+  getPageSize() {
+    return this.pageSize;
+  }
+  publishEventErrors = (e) => {
+    e.forEach((t) => {
+      if (t.fieldName) {
+        const r = m.t(t.errorMessage, { keySeparator: !1 });
+        this.emitter.emit("onFieldError", t.fieldName, r), this.emit({
+          type: 22,
+          fieldName: t.fieldName,
+          error: r,
+          originalError: t
+        });
+      } else
+        this.publishEventError(m.t(t.errorMessage, { keySeparator: !1 }), t);
+    });
+  };
+  publishEventError = (e, t) => {
+    this.emitter.emit("onError", e), this.emit({
+      type: 21,
+      error: e,
+      originalError: t
+    });
+  };
+  validate() {
+    if (this.validator && this.currentRecord) {
+      const e = this.validator.validateEntity(this.currentRecord);
+      if (e && e.length > 0)
+        if (this.publishEventErrors(e), e[0].fieldName) {
+          const t = m.t("archbase:errorSavingRecord", { dataSourceName: this.label });
+          throw new g(t);
+        } else
+          throw new g(e[0].errorMessage);
+    }
+    return !0;
+  }
+  async save(e) {
+    if (this.validateDataSourceActive("save"), !this.inserting && !this.editing) {
+      const r = m.t("archbase:saveRecordIsNotAllowed", { dataSourceName: this.name });
+      throw this.publishEventError(r, {}), new g(r);
+    }
+    if (!this.currentRecord) {
+      const r = m.t("archbase:noRecordToSave", { dataSourceName: this.name });
+      throw this.publishEventError(r, {}), new g(r);
+    }
+    if (this.emitter.emit("beforeSave", this.currentRecord, this.getCurrentIndex()), this.emit({
+      type: 16,
+      record: this.currentRecord,
+      index: this.getCurrentIndex()
+    }), this.validator) {
+      const r = this.validator.validateEntity(this.currentRecord);
+      if (r && r.length > 0)
+        if (this.publishEventErrors(r), r[0].fieldName) {
+          const i = m.t("archbase:errorSavingRecord", { dataSourceName: this.label });
+          throw new g(i);
+        } else
+          throw new g(r[0].errorMessage);
+    }
+    this.editing && (this.filteredRecords[this.getCurrentIndex()] = this.currentRecord);
+    let t = -1;
+    return this.records.forEach((r, i) => {
+      const s = this.getIdentity ? this.getIdentity(r) : r.id, o = this.getIdentity ? this.getIdentity(this.currentRecord) : this.currentRecord.id;
+      (r === this.currentRecord || s !== void 0 && s === o) && (t = i);
+    }), t >= 0 ? this.records[t] = this.currentRecord : this.records.push(this.currentRecord), this.editing = !1, this.inserting = !1, this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime(), this.emitter.emit("afterSave", this.currentRecord, this.getCurrentIndex()), this.emit({
+      type: 17,
+      record: this.currentRecord,
+      index: this.getCurrentIndex()
+    }), e && e(), this.currentRecord;
+  }
+  cancel() {
+    if (this.validateDataSourceActive("cancel"), !this.inserting && !this.editing) {
+      const e = m.t("archbase:notAllowCancelRecord", { dataSourceName: this.name });
+      throw this.publishEventError(e, {}), new g(e);
+    }
+    return this.emitter.emit("beforeCancel", this.currentRecord, this.currentRecordIndex), this.emit({
+      type: 18,
+      record: this.currentRecord,
+      index: this.getCurrentIndex()
+    }), this.inserting ? (this.filteredRecords.splice(this.currentRecordIndex, 1), this.currentRecord = this.oldRecord, this.currentRecordIndex = this.oldRecordIndex, this.grandTotalRecords--, this.emitter.emit("afterScroll"), this.emit({
+      type: 20
+      /* afterScroll */
+    }), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime()) : this.currentRecord = this.filteredRecords[this.currentRecordIndex], this.inserting = !1, this.editing = !1, this.emitter.emit("afterCancel", this.currentRecord, this.currentRecordIndex), this.emit({
+      type: 19,
+      record: this.currentRecord,
+      index: this.getCurrentIndex()
+    }), this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime(), this;
+  }
+  getCurrentPage() {
+    return this.currentPageIndex;
+  }
+  getTotalPages() {
+    return this.totalPages;
+  }
+  getTotalRecords() {
+    return this.filteredRecords.length;
+  }
+  getGrandTotalRecords() {
+    return this.grandTotalRecords;
+  }
+  getFieldValue(e, t = "") {
+    if (this.validateDataSourceActive("getFieldValue"), !e) {
+      const s = m.t("archbase:invalidFieldName", { dataSourceName: this.name });
+      throw this.publishEventError(s, {}), new g(s);
+    }
+    if (this.isEmpty() || this.isBOF() || this.isEOF() && !this.inserting)
+      return;
+    let r = this.filteredRecords[this.currentRecordIndex];
+    this.editing && (r = this.currentRecord);
+    let i = this.fieldValueByName(r, e);
+    return i === void 0 && t !== void 0 && (i = t), i;
+  }
+  fieldValueByName(e, t) {
+    if (e === void 0)
+      return;
+    const r = ye.getNestedProperty(e, t);
+    if (r !== void 0)
+      return we(r) ? Ee(r) : r;
+  }
+  setFieldValue(e, t) {
+    if (this.validateDataSourceActive("setFieldValue"), this.isEmpty() || !this.currentRecord)
+      return this;
+    if (!(this.inserting || this.editing || this.isBOF() || this.isEOF())) {
+      const o = m.t("archbase:recordNotBeingEdited", { dataSourceName: this.name });
+      throw this.publishEventError(o, {}), new g(o);
+    }
+    let r = t;
+    const i = ye.getNestedProperty(this.currentRecord, e);
+    return we(t) && (r = Ee(t)), e.split(".").length > 1 ? ye.setNestedProperty(this.currentRecord, e, r) : this.currentRecord[e] = r, this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime(), this.emitFieldChangeEvent(e, i, r), this.emitter.emit("fieldChanged", this.currentRecord, this.getCurrentIndex(), e, i, r), this.emit({
+      type: 3,
+      record: this.currentRecord,
+      index: this.getCurrentIndex(),
+      fieldName: e,
+      oldValue: i,
+      newValue: r
+    }), this;
+  }
+  isEmptyField(e) {
+    return this.validateDataSourceActive("isEmptyField"), this.getFieldValue(e) === void 0 || this.getFieldValue(e, "") === "";
+  }
+  getOptions() {
+    return {
+      pageSize: this.getPageSize(),
+      currentPage: this.getCurrentPage(),
+      records: this.records,
+      filters: this.filters,
+      grandTotalRecords: this.getGrandTotalRecords(),
+      totalPages: this.getTotalPages(),
+      filter: this.filter,
+      sort: this.sort,
+      originFilter: this.originFilter,
+      originSort: this.originSort,
+      originGlobalFilter: this.originGlobalFilter
+    };
+  }
+  refreshData(e) {
+    if (e)
+      this.emitter.emit("refreshData", e), this.emit({ type: 2, options: e });
+    else {
+      const t = this.getOptions();
+      this.emitter.emit("refreshData", t), this.emit({ type: 2, options: t });
+    }
+    this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime(), this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime();
+  }
+  browseRecords() {
+    return this.filteredRecords;
+  }
+  getCurrentIndex() {
+    return this.currentRecordIndex;
+  }
+  getCurrentRecord() {
+    return this.currentRecord;
+  }
+  isEOF() {
+    return this.currentRecordIndex > this.getTotalRecords() - 1 || this.isEmpty();
+  }
+  isBOF() {
+    return this.currentRecordIndex === -1;
+  }
+  isEmpty() {
+    return this.getTotalRecords() === 0;
+  }
+  isFirst() {
+    return this.currentRecordIndex === 0;
+  }
+  isLast() {
+    return this.currentRecordIndex === this.getTotalRecords() - 1;
+  }
+  next() {
+    if (this.validateDataSourceActive("next"), this.inserting || this.editing || this.isBOF() || this.isEOF()) {
+      const e = m.t("archbase:notAllowedBrowseRecords", { dataSourceName: this.name });
+      throw this.publishEventError(e, {}), new g(e);
+    }
+    return this.currentRecordIndex + 1 > this.getTotalRecords() - 1 ? (this.currentRecordIndex++, this.currentRecord = void 0) : (this.currentRecordIndex++, this.currentRecord = this.filteredRecords[this.currentRecordIndex], this.emitter.emit("afterScroll"), this.emit({
+      type: 20
+      /* afterScroll */
+    }), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime()), this;
+  }
+  prior() {
+    if (this.validateDataSourceActive("prior"), this.inserting || this.editing || this.isBOF() || this.isEOF()) {
+      const e = m.t("archbase:notAllowedBrowseRecords", { dataSourceName: this.name });
+      throw this.publishEventError(e, {}), new g(e);
+    }
+    return this.currentRecordIndex - 1 < 0 ? (this.currentRecordIndex = -1, this.currentRecord = void 0) : (this.currentRecordIndex--, this.currentRecord = this.filteredRecords[this.currentRecordIndex], this.emitter.emit("afterScroll"), this.emit({
+      type: 20
+      /* afterScroll */
+    }), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime()), this;
+  }
+  first() {
+    if (this.validateDataSourceActive("first"), this.inserting || this.editing) {
+      const e = m.t("archbase:notAllowedBrowseRecords", { dataSourceName: this.name });
+      throw this.publishEventError(e, {}), new g(e);
+    }
+    return this.getTotalRecords() === 0 ? (this.currentRecordIndex = -1, this.currentRecord = void 0) : (this.currentRecordIndex = 0, this.currentRecord = this.filteredRecords[this.currentRecordIndex], this.emitter.emit("afterScroll"), this.emit({
+      type: 20
+      /* afterScroll */
+    }), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime()), this;
+  }
+  last() {
+    if (this.validateDataSourceActive("last"), this.inserting || this.editing) {
+      const e = m.t("archbase:notAllowedBrowseRecords", { dataSourceName: this.name });
+      throw this.publishEventError(e, {}), new g(e);
+    }
+    return this.getTotalRecords() === 0 ? (this.currentRecordIndex = -1, this.currentRecord = void 0) : (this.currentRecordIndex = this.getTotalRecords() - 1, this.currentRecord = this.filteredRecords[this.currentRecordIndex], this.emitter.emit("afterScroll"), this.emit({
+      type: 20
+      /* afterScroll */
+    }), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime()), this;
+  }
+  gotoRecord(e) {
+    if (e === this.currentRecordIndex)
+      return this.currentRecord;
+    if (this.validateDataSourceActive("gotoRecord"), this.inserting || this.editing || this.isBOF() || this.isEOF()) {
+      const t = m.t("archbase:notAllowedBrowseRecords", { dataSourceName: this.name });
+      throw this.publishEventError(t, {}), new g(t);
+    }
+    if (e < 0 || e >= this.filteredRecords.length) {
+      const t = "Indice fora da faixa.";
+      throw this.publishEventError(t, {}), new g(t);
+    }
+    return this.currentRecordIndex = e, this.currentRecord = this.filteredRecords[this.currentRecordIndex], this.emitter.emit("afterScroll"), this.emit({
+      type: 20
+      /* afterScroll */
+    }), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime(), this.currentRecord;
+  }
+  gotoRecordByData(e) {
+    if (this.validateDataSourceActive("gotoRecordByData"), this.inserting || this.editing || this.isBOF() || this.isEOF()) {
+      const r = m.t("archbase:notAllowedBrowseRecords", { dataSourceName: this.name });
+      throw this.publishEventError(r, {}), new g(r);
+    }
+    if (this.isEmpty())
+      return !1;
+    if (this.currentRecord === e)
+      return this.emitter.emit("afterScroll"), this.emit({
+        type: 20
+        /* afterScroll */
+      }), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime(), !0;
+    let t = !1;
+    return this.filteredRecords.forEach((r, i) => {
+      e === r && (this.currentRecordIndex = i, this.currentRecord = r, this.emitter.emit("afterScroll"), this.emit({
+        type: 20
+        /* afterScroll */
+      }), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime(), t = !0);
+    }), t;
+  }
+  locate(e) {
+    if (!this.isBrowsing()) {
+      const i = m.t("archbase:notAllowedBrowseRecords", { dataSourceName: this.name });
+      throw this.publishEventError(i, {}), new g(i);
+    }
+    if (this.isEmpty())
+      return !1;
+    let t = -1, r = -1;
+    return this.records.forEach((i) => {
+      r++;
+      for (const s in e)
+        this.fieldValueByName(i, s) === e[s] && (t = r);
+    }), t >= 0 && this.gotoRecord(t), t >= 0;
+  }
+  locateByFilter(e) {
+    if (this.validateDataSourceActive("locate"), this.inserting || this.editing) {
+      const r = m.t("archbase:notAllowedBrowseRecords", { dataSourceName: this.name });
+      throw this.publishEventError(r, {}), new g(r);
+    }
+    if (this.isEmpty())
+      return !1;
+    const t = this.filteredRecords.findIndex(e);
+    return t !== -1 && this.gotoRecord(t), t >= 0;
+  }
+  addListener(e) {
+    return this.listeners.has(e) || this.listeners.add(e), this;
+  }
+  removeListener(e) {
+    return this.listeners.has(e) && this.listeners.delete(e), this;
+  }
+  on(e, t) {
+    this.emitter.on(e, t);
+  }
+  off(e, t) {
+    this.emitter.off(e, t);
+  }
+  addFieldChangeListener(e, t) {
+    const r = e.split(".");
+    let i = "";
+    return r.forEach((s, o) => {
+      i = o === 0 ? s : `${i}.${s}`, this.fieldEventListeners[`field:${i}`] || (this.fieldEventListeners[`field:${i}`] = []), this.fieldEventListeners[`field:${i}`].includes(t) || this.fieldEventListeners[`field:${i}`].push(t);
+    }), this;
+  }
+  removeFieldChangeListener(e, t) {
+    const r = e.split(".");
+    let i = "";
+    return r.forEach((s, o) => {
+      i = o === 0 ? s : `${i}.${s}`;
+      const c = this.fieldEventListeners[`field:${i}`];
+      if (c) {
+        const f = c.indexOf(t);
+        f !== -1 && c.splice(f, 1);
+      }
+    }), this;
+  }
+  emitFieldChangeEvent(e, t, r) {
+    const i = e.split(".");
+    let s = "";
+    for (const o of i) {
+      s = s ? `${s}.${o}` : o;
+      const c = this.fieldEventListeners[`field:${s}`];
+      c && c.forEach((f) => f(s, t, r));
+    }
+  }
+  /**
+   * Define um erro para um campo específico
+   * @param fieldName Nome do campo
+   * @param errors Array de mensagens de erro
+   */
+  setFieldError(e, t) {
+    t && t.length > 0 && (this.emitter.emit("onFieldError", e, t[0]), this.emit({
+      type: 22,
+      fieldName: e,
+      error: t[0],
+      originalError: t
+    }));
+  }
+}
+class Ce extends Ie {
+  service;
+  constructor(e, t, r, i) {
+    super(t, r, i), this.service = e;
+  }
+  async save(e) {
+    if (this.validateDataSourceActive("save"), !this.inserting && !this.editing) {
+      const t = m.t("archbase:saveRecordIsNotAllowed", { dataSourceName: this.name });
+      throw this.publishEventError(t, {}), new g(t);
+    }
+    if (!this.currentRecord) {
+      const t = m.t("archbase:noRecordToSave", { dataSourceName: this.name });
+      throw this.publishEventError(t, {}), new g(t);
+    }
+    if (this.emitter.emit("beforeSave", this.currentRecord), this.emit({
+      type: d.beforeSave,
+      record: this.currentRecord,
+      index: this.getCurrentIndex()
+    }), this.validator) {
+      const t = this.validator.validateEntity(this.currentRecord);
+      if (t && t.length > 0)
+        if (this.publishEventErrors(t), t[0].fieldName) {
+          const r = m.t("archbase:errorSavingRecord", { dataSourceName: this.label });
+          throw new g(r);
+        } else
+          throw new g(t[0].errorMessage);
+    }
+    try {
+      let t = -1;
+      this.records.forEach((r, i) => {
+        const s = this.getIdentity ? this.getIdentity(r) : r.id, o = this.getIdentity ? this.getIdentity(this.currentRecord) : this.currentRecord.id;
+        (r === this.currentRecord || s !== void 0 && s === o) && (t = i);
+      }), this.currentRecord = await this.service.save(this.currentRecord), this.editing && (this.filteredRecords = [...this.filteredRecords], this.filteredRecords[this.getCurrentIndex()] = this.currentRecord), this.records = [...this.records], t >= 0 ? this.records[t] = this.currentRecord : this.records.push(this.currentRecord), this.editing = !1, this.inserting = !1, this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime(), this.emitter.emit("afterSave", this.currentRecord), this.emit({
+        type: d.afterSave,
+        record: this.currentRecord,
+        index: this.getCurrentIndex()
+      }), e && e();
+    } catch (t) {
+      t.response && t.response.data && t.response.data.apierror && t.response.data.apierror.subErrors && t.response.data.apierror.subErrors.forEach((i) => {
+        if (i.field) {
+          const s = m.t(i.message, { defaultValue: i.message });
+          this.emitter.emit("onFieldError", i.field, s), this.emit({
+            type: d.onFieldError,
+            fieldName: i.field,
+            error: s,
+            originalError: i.message
+          });
+        }
+      });
+      const r = k(t);
+      throw this.emitter.emit("onError", r, t), this.emit({
+        type: d.onError,
+        error: r,
+        originalError: t
+      }), e && e(r), new g(r);
+    }
+    return this.currentRecord;
+  }
+  async remove(e) {
+    if (this.validateDataSourceActive("remove"), this.inserting || this.editing) {
+      const t = m.t("archbase:removingRecordIsNotAllowed", { dataSourceName: this.name });
+      throw this.publishEventError(t, {}), new g(
+        t
+      );
+    }
+    if (this.isEmpty() || !this.currentRecord) {
+      const t = m.t("archbase:noRecordsToEdit", { dataSourceName: this.name });
+      throw this.publishEventError(t, {}), new g(t);
+    }
+    if (this.isBOF()) {
+      const t = m.t("archbase:BOFDataSource", { dataSourceName: this.name });
+      throw this.publishEventError(t, {}), new g(t);
+    }
+    if (this.isEOF()) {
+      const t = m.t("archbase:EOFDataSource", { dataSourceName: this.name });
+      throw this.publishEventError(t, {}), new g(t);
+    }
+    this.emitter.emit("beforeRemove", this.currentRecord, this.currentRecordIndex), this.emit({
+      type: d.beforeRemove,
+      record: this.currentRecord,
+      index: this.getCurrentIndex()
+    });
+    try {
+      await this.service.delete(this.service.getId(this.currentRecord));
+      let t = -1;
+      const r = this.currentRecord, i = this.currentRecordIndex;
+      return this.records = [...this.records], this.filteredRecords = [...this.filteredRecords], this.records.forEach((s, o) => {
+        this.currentRecord === s && (t = o);
+      }), t >= 0 && this.records.splice(t, 1), this.records !== this.filteredRecords && this.filteredRecords.splice(this.getCurrentIndex(), 1), this.grandTotalRecords--, this.filteredRecords.length === 0 ? (this.currentRecord = void 0, this.currentRecordIndex = -1) : (this.currentRecordIndex > this.filteredRecords.length - 1 && this.currentRecordIndex--, this.currentRecord = this.filteredRecords[this.currentRecordIndex]), this.editing = !1, this.inserting = !1, this.emitter.emit("afterScroll"), this.emit({ type: d.afterScroll }), this.emitter.emit("afterRemove", r, i), this.emit({
+        type: d.afterRemove,
+        record: r,
+        index: i
+      }), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime(), this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime(), e && e(), r;
+    } catch (t) {
+      const r = k(t);
+      throw this.emitter.emit("onError", r, t), this.emit({
+        type: d.onError,
+        error: r,
+        originalError: t
+      }), e && e(r), new g(r);
+    }
+  }
+  applyRemoteFilter(e, t, r) {
+    return e && e.filter.filterType === Se && e.filter.quickFilterText && e.filter.quickFilterText !== "" ? this.getDataWithQuickFilter(e, t) : e && (e.filter.filterType === Fe || e.filter.filterType === Ae) ? this.getDataWithFilter(e, t) : this.getDataWithoutFilter(t);
+  }
+  async getDataWithFilter(e, t) {
+    const r = new xe();
+    r.buildFrom(e.filter, e.sort);
+    const i = r.toJSON();
+    let s;
+    return i ? s = await this.service.findAllWithFilter(i, t, this.getPageSize()) : s = this.getDataWithoutFilter(t), s;
+  }
+  getDataWithoutFilter(e) {
+    let t;
+    return this.defaultSortFields.length > 0 ? t = this.service.findAllWithSort(e, this.getPageSize(), this.defaultSortFields) : t = this.service.findAll(e, this.getPageSize()), t;
+  }
+  getDataWithQuickFilter(e, t) {
+    return this.service.findAllMultipleFields(
+      e.filter.quickFilterText,
+      e.filter.quickFilterFieldsText,
+      t,
+      this.getPageSize(),
+      this.getSortFields(e)
+    );
+  }
+  getSortFields(e) {
+    return e && e.sort ? e.sort.quickFilterSort : this.defaultSortFields;
+  }
+}
+class Ge {
+  id;
+  companyId;
+  filter;
+  name;
+  description;
+  viewName;
+  componentName;
+  componentId;
+  userName;
+  userOwner;
+  shared;
+  readOnly;
+  code;
+  constructor(e = {}) {
+    Object.assign(this, e);
+  }
+}
+class ke extends Ie {
+  getFilterById(e) {
+    if (this.locate({ id: e }))
+      return this.convertCurrentRecordToFilter();
+  }
+  convertCurrentRecordToFilter() {
+    return new ue({
+      id: this.getFieldValue("id"),
+      name: this.getFieldValue("name"),
+      description: this.getFieldValue("description"),
+      companyId: this.getFieldValue("companyId"),
+      componentId: this.getFieldValue("componentId") || this.getFieldValue("componentName"),
+      userOwner: this.getFieldValue("userOwner") || this.getFieldValue("userName"),
+      shared: this.getFieldValue("shared"),
+      readOnly: this.getFieldValue("readOnly"),
+      filter: this.getFieldValue("filter") ? atob(this.getFieldValue("filter")) : void 0
+    });
+  }
+  async addNewFilter(e, t) {
+    this.insert(
+      new Ge({
+        id: e.id,
+        name: e.name,
+        description: e.description,
+        companyId: e.companyId,
+        componentId: e.componentId,
+        componentName: e.componentId,
+        userOwner: e.userOwner,
+        userName: e.userOwner,
+        filter: e.filter ? btoa(JSON.stringify(e.filter)) : void 0,
+        shared: e.shared,
+        readOnly: e.readOnly
+      })
+    );
+    const r = await this.save();
+    t(null, r.id);
+  }
+  async saveFilter(e, t) {
+    if (this.locate({ id: e.id })) {
+      this.edit(), this.setFieldValue("filter", btoa(JSON.stringify(e.filter)));
+      const r = await this.save();
+      t(null, r.id);
+    } else
+      t("Filtro não encontrado.");
+  }
+  async removeFilterBy(e, t) {
+    this.locate({ id: e.id }) ? (await this.remove(), t(null, e.id)) : t("Filtro não encontrado.");
+  }
+  getFirstFilter() {
+    if (this.getTotalRecords() > 0)
+      return this.first(), this.convertCurrentRecordToFilter();
+  }
+  getFilters() {
+    return this.getTotalRecords() > 0 ? this.browseRecords().map(
+      (e) => new ue({
+        id: e.id,
+        name: e.name,
+        description: e.description,
+        companyId: e.companyId,
+        componentId: e.componentId || e.componentName,
+        userOwner: e.userOwner || e.userName,
+        shared: e.shared,
+        readOnly: e.readOnly,
+        filter: e.filter ? atob(e.filter) : void 0
+      })
+    ) : [];
+  }
+}
+class qe {
+  id;
+  companyId;
+  filter;
+  name;
+  description;
+  viewName;
+  componentName;
+  componentId;
+  userName;
+  userOwner;
+  shared;
+  readOnly;
+  code;
+  isNewFilter;
+  constructor(e = {}) {
+    Object.assign(this, e);
+  }
+}
+class _e extends Ce {
+  getFilterById(e) {
+    if (this.locate({ id: e }))
+      return this.convertCurrentRecordToFilter();
+  }
+  convertCurrentRecordToFilter() {
+    return new ue({
+      id: this.getFieldValue("id"),
+      name: this.getFieldValue("name"),
+      description: this.getFieldValue("description"),
+      companyId: this.getFieldValue("companyId"),
+      componentId: this.getFieldValue("componentId") || this.getFieldValue("componentName"),
+      userOwner: this.getFieldValue("userOwner") || this.getFieldValue("userName"),
+      shared: this.getFieldValue("shared"),
+      readOnly: this.getFieldValue("readOnly"),
+      filter: this.getFieldValue("filter") ? atob(this.getFieldValue("filter")) : void 0
+    });
+  }
+  async addNewFilter(e, t) {
+    this.insert(
+      new qe({
+        id: e.id,
+        name: e.name,
+        description: e.description,
+        companyId: e.companyId,
+        componentId: e.componentId,
+        componentName: e.componentId,
+        userOwner: e.userOwner,
+        userName: e.userOwner,
+        filter: e.filter ? btoa(JSON.stringify(e.filter)) : void 0,
+        shared: e.shared,
+        readOnly: e.readOnly
+      })
+    );
+    const r = await this.save();
+    t(null, r.id);
+  }
+  async saveFilter(e, t) {
+    if (this.locate({ id: e.id })) {
+      this.edit(), this.setFieldValue("filter", btoa(JSON.stringify(e.filter)));
+      const r = await this.save((i) => {
+        t(i, r.id);
+      });
+    } else
+      t("Filtro não encontrado.");
+  }
+  async removeFilterBy(e, t) {
+    this.locate({ id: e.id }) ? await this.remove((r) => {
+      t(r, e.id);
+    }) : t("Filtro não encontrado.");
+  }
+  getFirstFilter() {
+    if (this.getTotalRecords() > 0)
+      return this.first(), this.convertCurrentRecordToFilter();
+  }
+  getFilters() {
+    return this.getTotalRecords() > 0 ? this.browseRecords().map(
+      (e) => new ue({
+        id: e.id,
+        name: e.name,
+        description: e.description,
+        companyId: e.companyId,
+        componentId: e.componentId || e.componentName,
+        userOwner: e.userOwner || e.userName,
+        shared: e.shared,
+        readOnly: e.readOnly,
+        filter: e.filter ? atob(e.filter) : void 0
+      })
+    ) : [];
+  }
+}
+function pt(n, e, t, r) {
+  const i = e && ("appendToFieldArray" in e || "updateFieldArrayItem" in e), [s, o] = C(r), [, c] = C(0), f = l(() => {
+    c((u) => u + 1);
+  }, []), [R, b] = C(r), [N, W] = C(0), T = l(() => {
+    let u = r;
+    e && t && (u = e.getFieldValue(t), u == null && (u = r)), i ? (b(u), W((a) => a + 1)) : o(u);
+  }, [e, t, r, i]), O = l((u) => {
+    e && t && ((u.type === d.dataChanged || u.type === d.recordChanged || u.type === d.afterScroll || u.type === d.afterCancel || u.type === d.afterEdit) && (T(), i || f()), u.type === d.onFieldError && u.fieldName === t && console.warn(`[${n}] Field error:`, u.error));
+  }, [e, t, T, f, i, n]), $ = l((u, a) => {
+    i ? (b(u), e && !e.isBrowsing() && t && e.getFieldValue(t) !== u && e.setFieldValue(t, u)) : (o(u), e && !e.isBrowsing() && t && e.getFieldValue(t) !== u && e.setFieldValue(t, u));
+  }, [e, t, i]), z = l(() => {
+    const u = ve(e);
+    Ne.trackV2Usage(n, u);
+  }, [n, e]);
+  return le(() => {
+    process.env.NODE_ENV === "production" && z();
+  }).current, {
+    // Detecção de versão
+    isDataSourceV2: i,
+    dataSourceVersion: ve(e),
+    // Estados
+    currentValue: i ? R : s,
+    v1State: { currentValue: s, setCurrentValue: o, forceUpdate: f },
+    v2State: { v2Value: R, setV2Value: b, v2ShouldUpdate: N },
+    // Funções
+    loadDataSourceFieldValue: T,
+    dataSourceEvent: O,
+    handleValueChange: $,
+    // Utilitários
+    isReadOnly: e ? e.isBrowsing() : !1,
+    isEditing: e ? e.isEditing() : !1,
+    trackUsage: z
+  };
+}
+const yt = {
+  /**
+   * Valida se o componente está seguindo o padrão corretamente
+   */
+  validatePattern: (n, e) => {
+    const t = [];
+    return e.dataSourceVersion === "NONE" && e.isDataSourceV2 && t.push("DataSource version detection inconsistent"), e.isDataSourceV2 && e.v1State.currentValue === e.currentValue && t.push("V2 should use v2Value, not v1 currentValue"), !e.isDataSourceV2 && e.v2State.v2Value === e.currentValue && t.push("V1 should use currentValue, not v2Value"), t.length > 0 ? (console.error(`[${n}] Migration pattern validation failed:`, t), !1) : !0;
+  },
+  /**
+   * Testa se o comportamento V1 está preservado
+   */
+  testV1Compatibility: (n, e) => !e || ve(e) !== "V1" || [
+    "isBrowsing",
+    "isEditing",
+    "getFieldValue",
+    "setFieldValue"
+  ].every((r) => typeof e[r] == "function") ? !0 : (console.error(`[${n}] V1 DataSource missing required methods`), !1)
+}, vt = `
+// Em qualquer componente que use DataSource:
+
+import { useArchbaseV1V2Compatibility } from '../core/patterns/ArchbaseV1V2CompatibilityPattern';
+
+export function MyComponent<T, ID>({ dataSource, dataField, value, onChangeValue, ...props }) {
+  // 1. USAR HOOK DE COMPATIBILIDADE (OBRIGATÓRIO)
+  const {
+    isDataSourceV2,
+    currentValue,
+    handleValueChange,
+    dataSourceEvent,
+    loadDataSourceFieldValue,
+    isReadOnly
+  } = useArchbaseV1V2Compatibility<T>(
+    'MyComponent',
+    dataSource,
+    dataField,
+    value
+  );
+
+  // 2. SETUP DOS LISTENERS (OBRIGATÓRIO)
+  useArchbaseDataSourceListener({
+    dataSource,
+    listener: dataSourceEvent
+  });
+
+  // 3. CARREGAMENTO INICIAL (OBRIGATÓRIO)
+  useEffect(() => {
+    loadDataSourceFieldValue();
+  }, [loadDataSourceFieldValue]);
+
+  // 4. HANDLER DE MUDANÇA (OBRIGATÓRIO)
+  const handleChange = useCallback((newValue: T, event: any) => {
+    handleValueChange(newValue, event);
+    
+    // Callback externo preservado
+    if (onChangeValue) {
+      onChangeValue(newValue, event);
+    }
+  }, [handleValueChange, onChangeValue]);
+
+  // 5. RENDERIZAÇÃO CONDICIONAL (OBRIGATÓRIO)
+  return (
+    <SomeInput
+      value={currentValue} // Usa valor correto baseado na versão
+      onChange={handleChange}
+      readOnly={isReadOnly}
+      {...props}
+    />
+  );
+}
+`;
+class U {
+  name;
+  label;
+  records = [];
+  currentIndex = -1;
+  state = "browse";
+  listeners = /* @__PURE__ */ new Set();
+  originalRecord = null;
+  validator;
+  lastDataChangedAt = 0;
+  active = !0;
+  // Callbacks V2
+  onStateChange;
+  onFieldError;
+  onError;
+  constructor(e) {
+    this.name = e.name, this.label = e.label || e.name, this.validator = e.validator, this.onStateChange = e.onStateChange, this.onFieldError = e.onFieldError, this.onError = e.onError, e.records && (this.records = [...e.records], this.records.length > 0 && (this.currentIndex = 0)), this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime();
+  }
+  // =================== Basic Properties ===================
+  getName() {
+    return this.name;
+  }
+  getLabel() {
+    return this.label;
+  }
+  isActive() {
+    return this.active;
+  }
+  close() {
+    this.active = !1, this.listeners.clear();
+  }
+  // =================== Record Management ===================
+  getCurrentRecord() {
+    if (this.currentIndex >= 0 && this.currentIndex < this.records.length)
+      return this.records[this.currentIndex];
+  }
+  getCurrentIndex() {
+    return this.currentIndex;
+  }
+  getTotalRecords() {
+    return this.records.length;
+  }
+  isEmpty() {
+    return this.records.length === 0;
+  }
+  // =================== Navigation ===================
+  first() {
+    return this.records.length > 0 && (this.currentIndex = 0, this.emit({
+      type: d.afterScroll
+    })), this;
+  }
+  last() {
+    return this.records.length > 0 && (this.currentIndex = this.records.length - 1, this.emit({
+      type: d.afterScroll
+    })), this;
+  }
+  next() {
+    return this.currentIndex < this.records.length - 1 && (this.currentIndex++, this.emit({
+      type: d.recordChanged,
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    })), this;
+  }
+  prior() {
+    return this.currentIndex > 0 && (this.currentIndex--, this.emit({
+      type: d.recordChanged,
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    })), this;
+  }
+  goToRecord(e) {
+    if (e >= 0 && e < this.records.length)
+      return this.currentIndex = e, this.emit({
+        type: d.recordChanged,
+        record: this.getCurrentRecord(),
+        index: this.currentIndex
+      }), this.getCurrentRecord();
+  }
+  isFirst() {
+    return this.currentIndex === 0;
+  }
+  isLast() {
+    return this.currentIndex === this.records.length - 1;
+  }
+  isBOF() {
+    return this.currentIndex < 0;
+  }
+  isEOF() {
+    return this.currentIndex >= this.records.length;
+  }
+  // =================== State Management ===================
+  isBrowsing() {
+    return this.state === "browse";
+  }
+  isEditing() {
+    return this.state === "edit";
+  }
+  isInserting() {
+    return this.state === "insert";
+  }
+  edit() {
+    if (this.validateDataSourceActive("edit"), this.isEmpty() || !this.getCurrentRecord())
+      throw new Error(`No records to edit in DataSource ${this.name}`);
+    return this.state = "edit", this.originalRecord = JSON.parse(JSON.stringify(this.getCurrentRecord())), this.emit({
+      type: d.beforeEdit,
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    }), this.emit({
+      type: d.afterEdit,
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    }), this;
+  }
+  cancel() {
+    return this.validateDataSourceActive("cancel"), this.state === "edit" && this.originalRecord ? (this.records = [...this.records], this.records[this.currentIndex] = { ...this.originalRecord }) : this.state === "insert" && (this.records = this.records.slice(0, -1), this.records.length > 0 ? this.currentIndex = Math.min(this.currentIndex, this.records.length - 1) : this.currentIndex = -1), this.state = "browse", this.originalRecord = null, this.emit({
+      type: d.afterCancel,
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    }), this;
+  }
+  insert(e) {
+    return this.validateDataSourceActive("insert"), this.state = "insert", this.emit({
+      type: d.beforeInsert
+    }), this.records = [...this.records, e], this.currentIndex = this.records.length - 1, this.notifyStateChange(), this.emit({
+      type: d.afterInsert,
+      record: e,
+      index: this.currentIndex
+    }), this;
+  }
+  async save(e) {
+    if (this.validateDataSourceActive("save"), !this.isInserting() && !this.isEditing())
+      throw new Error(`Save not allowed in current state for DataSource ${this.name}`);
+    if (!this.getCurrentRecord())
+      throw new Error(`No record to save in DataSource ${this.name}`);
+    const t = this.getCurrentRecord();
+    if (this.emit({
+      type: d.beforeSave,
+      record: t,
+      index: this.getCurrentIndex()
+    }), this.validator) {
+      const r = this.validator.validateEntity(t);
+      if (r && r.length > 0)
+        throw new Error(r[0].errorMessage);
+    }
+    return this.state = "browse", this.originalRecord = null, this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime(), this.notifyStateChange(), this.emit({
+      type: d.afterSave,
+      record: t,
+      index: this.getCurrentIndex()
+    }), e && e(), t;
+  }
+  async remove(e) {
+    if (this.validateDataSourceActive("remove"), this.isInserting() || this.isEditing())
+      throw new Error(`Remove not allowed in current state for DataSource ${this.name}`);
+    if (this.isEmpty() || !this.getCurrentRecord())
+      throw new Error(`No records to remove in DataSource ${this.name}`);
+    const t = this.getCurrentRecord(), r = this.currentIndex;
+    return this.emit({
+      type: d.beforeRemove,
+      record: t,
+      index: r
+    }), this.records = this.records.filter((i, s) => s !== this.currentIndex), this.records.length === 0 ? this.currentIndex = -1 : this.currentIndex >= this.records.length && (this.currentIndex = this.records.length - 1), this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime(), this.notifyStateChange(), this.emit({ type: d.afterScroll }), this.emit({
+      type: d.afterRemove,
+      record: t,
+      index: r
+    }), e && e(), t;
+  }
+  // =================== Field Operations ===================
+  setFieldValue(e, t) {
+    if (this.validateDataSourceActive("setFieldValue"), !this.getCurrentRecord())
+      return this;
+    const r = this.getFieldValue(e);
+    if (r === t)
+      return this;
+    const i = [...this.records];
+    return this.records = _(this.records, (s) => {
+      const o = s[this.currentIndex];
+      o && this.setNestedValue(o, e, t);
+    }), this.notifyStateChange(i), this.emit({
+      type: d.fieldChanged,
+      fieldName: e,
+      oldValue: r,
+      newValue: t,
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    }), this.emit({
+      type: d.dataChanged,
+      data: this.records
+    }), this;
+  }
+  getFieldValue(e) {
+    const t = this.getCurrentRecord();
+    if (t)
+      return this.getNestedValue(t, e);
+  }
+  // =================== Array Field Operations (V2) ===================
+  appendToFieldArray(e, t) {
+    if (this.validateDataSourceActive("appendToFieldArray"), !this.getCurrentRecord())
+      return;
+    const r = this.getFieldValue(e);
+    if (r == null) {
+      console.warn(`appendToFieldArray: Field ${String(e)} is undefined/null. Initialize the array in your DTO before using appendToFieldArray.`);
+      return;
+    }
+    if (!Array.isArray(r))
+      throw new Error(`Field ${String(e)} is not an array (found: ${typeof r})`);
+    const i = [...this.records];
+    this.records = _(this.records, (s) => {
+      const o = s[this.currentIndex];
+      if (o) {
+        const c = this.getNestedValue(o, e);
+        c && c.push(t);
+      }
+    }), this.notifyStateChange(i), this.emit({
+      type: d.fieldChanged,
+      fieldName: e,
+      oldValue: r,
+      newValue: [...r, t],
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    });
+  }
+  updateFieldArrayItem(e, t, r) {
+    if (this.validateDataSourceActive("updateFieldArrayItem"), !this.getCurrentRecord())
+      return;
+    const i = this.getFieldValue(e);
+    if (!Array.isArray(i) || t < 0 || t >= i.length)
+      return;
+    const s = [...this.records];
+    this.records = _(this.records, (o) => {
+      const c = o[this.currentIndex];
+      if (c) {
+        const f = this.getNestedValue(c, e);
+        f[t] !== void 0 && r(f[t]);
+      }
+    }), this.notifyStateChange(s), this.emit({
+      type: d.fieldChanged,
+      fieldName: e,
+      oldValue: i,
+      newValue: this.getFieldValue(e),
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    });
+  }
+  removeFromFieldArray(e, t) {
+    if (this.validateDataSourceActive("removeFromFieldArray"), !this.getCurrentRecord())
+      return;
+    const r = this.getFieldValue(e);
+    if (!Array.isArray(r))
+      throw new Error(`Field ${String(e)} is not an array`);
+    if (t < 0 || t >= r.length)
+      return;
+    const i = [...this.records];
+    this.records = _(this.records, (s) => {
+      const o = s[this.currentIndex];
+      o && this.getNestedValue(o, e).splice(t, 1);
+    }), this.notifyStateChange(i), this.emit({
+      type: d.fieldChanged,
+      fieldName: e,
+      oldValue: r,
+      newValue: this.getFieldValue(e),
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    });
+  }
+  insertIntoFieldArray(e, t, r) {
+    if (this.validateDataSourceActive("insertIntoFieldArray"), !this.getCurrentRecord())
+      return;
+    const i = this.getFieldValue(e);
+    if (!Array.isArray(i))
+      throw new Error(`Field ${String(e)} is not an array`);
+    const s = [...this.records];
+    this.records = _(this.records, (o) => {
+      const c = o[this.currentIndex];
+      c && this.getNestedValue(c, e).splice(t, 0, r);
+    }), this.notifyStateChange(s), this.emit({
+      type: d.fieldChanged,
+      fieldName: e,
+      oldValue: i,
+      newValue: this.getFieldValue(e),
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    });
+  }
+  getFieldArray(e) {
+    const t = this.getFieldValue(e);
+    return t == null ? [] : Array.isArray(t) ? t : (console.warn(`Field ${String(e)} is not an array (found: ${typeof t}), returning empty array`), []);
+  }
+  isFieldArray(e) {
+    const t = this.getFieldValue(e);
+    return Array.isArray(t);
+  }
+  // =================== Interface Compatibility Methods ===================
+  /**
+   * Abre o DataSource com os dados fornecidos.
+   * Aceita tanto o formato completo DataSourceOptions quanto um formato simplificado { records: T[] }
+   */
+  open(e) {
+    this.setData(e);
+  }
+  clear() {
+    this.records = [], this.currentIndex = -1, this.state = "browse", this.originalRecord = null, this.emit({
+      type: d.dataChanged,
+      data: this.records
+    });
+  }
+  /**
+   * Define os dados do DataSource.
+   * Quando apenas records é informado, os valores de paginação são derivados automaticamente.
+   */
+  setData(e) {
+    this.records = [...e.records || []], this.currentIndex = this.records.length > 0 ? 0 : -1, this.state = "browse", this.originalRecord = null, this.emit({
+      type: d.dataChanged,
+      data: this.records
+    });
+  }
+  getOptions() {
+    return {
+      records: [...this.records],
+      grandTotalRecords: this.records.length,
+      currentPage: 0,
+      totalPages: 1,
+      pageSize: this.records.length || 10
+    };
+  }
+  refreshData(e) {
+    e && this.setData(e);
+  }
+  browseRecords() {
+    return [...this.records];
+  }
+  getGrandTotalRecords() {
+    return this.records.length;
+  }
+  getCurrentPage() {
+    return 0;
+  }
+  getTotalPages() {
+    return 1;
+  }
+  isEmptyField(e) {
+    const t = this.getFieldValue(e);
+    return t == null || t === "";
+  }
+  goToPage(e) {
+    return this;
+  }
+  gotoRecordByData(e) {
+    const t = this.records.findIndex((r) => r === e);
+    return t >= 0 ? (this.currentIndex = t, this.emit({
+      type: d.recordChanged,
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    }), !0) : !1;
+  }
+  disabledAllListeners() {
+    return this;
+  }
+  enableAllListeners() {
+    return this;
+  }
+  addFieldChangeListener(e, t) {
+    const r = (i) => {
+      i.type === d.fieldChanged && "fieldName" in i && i.fieldName === e && t(e, i.oldValue, i.newValue);
+    };
+    return this.addListener(r), this;
+  }
+  removeFieldChangeListener(e, t) {
+    return this;
+  }
+  addFilter(e) {
+    return this;
+  }
+  removeFilter(e) {
+    return this;
+  }
+  clearFilters() {
+    return this;
+  }
+  locate(e) {
+    for (let t = 0; t < this.records.length; t++) {
+      const r = this.records[t];
+      let i = !0;
+      for (const [s, o] of Object.entries(e))
+        if (this.getNestedValue(r, s) !== o) {
+          i = !1;
+          break;
+        }
+      if (i)
+        return this.currentIndex = t, this.emit({
+          type: d.recordChanged,
+          record: this.getCurrentRecord(),
+          index: this.currentIndex
+        }), !0;
+    }
+    return !1;
+  }
+  locateByFilter(e) {
+    for (let t = 0; t < this.records.length; t++)
+      if (e(this.records[t]))
+        return this.currentIndex = t, this.emit({
+          type: d.recordChanged,
+          record: this.getCurrentRecord(),
+          index: this.currentIndex
+        }), !0;
+    return !1;
+  }
+  validate() {
+    return !0;
+  }
+  // =================== Event Management ===================
+  addListener(...e) {
+    return e.forEach((t) => this.listeners.add(t)), this;
+  }
+  removeListener(...e) {
+    return e.forEach((t) => this.listeners.delete(t)), this;
+  }
+  emit(e) {
+    this.listeners.forEach((t) => {
+      try {
+        t(e);
+      } catch (r) {
+        console.error("Error in DataSource listener:", r);
+      }
+    });
+  }
+  // =================== Utility Methods ===================
+  getRecords() {
+    return [...this.records];
+  }
+  setRecords(e) {
+    const t = [...this.records];
+    this.records = [...e], e.length > 0 ? this.currentIndex = 0 : this.currentIndex = -1, this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime(), this.notifyStateChange(t), this.emit({
+      type: d.dataChanged,
+      data: this.records
+    });
+  }
+  // =================== Debug Support ===================
+  getDebugSnapshot() {
+    return {
+      name: this.name,
+      recordCount: this.records.length,
+      currentIndex: this.currentIndex,
+      currentRecord: this.getCurrentRecord(),
+      state: this.state,
+      listeners: this.listeners.size
+    };
+  }
+  // =================== Private Helper Methods ===================
+  validateDataSourceActive(e) {
+    if (!this.active)
+      throw new Error(`DataSource ${this.name} is not active. Cannot perform ${e}`);
+  }
+  notifyStateChange(e) {
+    this.onStateChange && e && this.onStateChange(e, [...this.records]);
+  }
+  setNestedValue(e, t, r) {
+    const i = t.split(".");
+    let s = e;
+    for (let o = 0; o < i.length - 1; o++) {
+      const c = i[o];
+      c in s || (s[c] = {}), s = s[c];
+    }
+    s[i[i.length - 1]] = r;
+  }
+  getNestedValue(e, t) {
+    const r = t.split(".");
+    let i = e;
+    for (const s of r) {
+      if (i == null)
+        return;
+      i = i[s];
+    }
+    return i;
+  }
+}
+class Je {
+  name;
+  label;
+  service;
+  records = [];
+  filteredRecords = [];
+  currentIndex = -1;
+  state = "browse";
+  listeners = /* @__PURE__ */ new Set();
+  originalRecord = null;
+  validator;
+  lastDataChangedAt = 0;
+  lastDataBrowsingOn = 0;
+  grandTotalRecords = 0;
+  defaultSortFields = [];
+  pageSize = 20;
+  active = !0;
+  // Callbacks V2
+  onStateChange;
+  onFieldError;
+  onError;
+  constructor(e) {
+    this.name = e.name, this.label = e.label || e.name, this.service = e.service, this.validator = e.validator, this.defaultSortFields = e.defaultSortFields || [], this.pageSize = e.pageSize || 20, this.onStateChange = e.onStateChange, this.onFieldError = e.onFieldError, this.onError = e.onError, e.records && (this.records = [...e.records], this.filteredRecords = [...this.records], this.grandTotalRecords = this.records.length, this.records.length > 0 && (this.currentIndex = 0)), this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime(), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime();
+  }
+  // =================== Basic Properties ===================
+  getName() {
+    return this.name;
+  }
+  getLabel() {
+    return this.label;
+  }
+  isActive() {
+    return this.active;
+  }
+  close() {
+    this.active = !1, this.listeners.clear();
+  }
+  // =================== Record Management ===================
+  getCurrentRecord() {
+    if (this.currentIndex >= 0 && this.currentIndex < this.filteredRecords.length)
+      return this.filteredRecords[this.currentIndex];
+  }
+  getCurrentIndex() {
+    return this.currentIndex;
+  }
+  getTotalRecords() {
+    return this.filteredRecords.length;
+  }
+  isEmpty() {
+    return this.filteredRecords.length === 0;
+  }
+  // =================== Navigation ===================
+  first() {
+    this.filteredRecords.length > 0 && (this.currentIndex = 0, this.emit({
+      type: d.afterScroll
+    }));
+  }
+  last() {
+    this.filteredRecords.length > 0 && (this.currentIndex = this.filteredRecords.length - 1, this.emit({
+      type: d.afterScroll
+    }));
+  }
+  next() {
+    this.currentIndex < this.filteredRecords.length - 1 && (this.currentIndex++, this.emit({
+      type: d.afterScroll
+    }));
+  }
+  prior() {
+    this.currentIndex > 0 && (this.currentIndex--, this.emit({
+      type: d.afterScroll
+    }));
+  }
+  goToRecord(e) {
+    e >= 0 && e < this.filteredRecords.length && (this.currentIndex = e, this.emit({
+      type: d.afterScroll
+    }));
+  }
+  isFirst() {
+    return this.currentIndex === 0;
+  }
+  isLast() {
+    return this.currentIndex === this.filteredRecords.length - 1;
+  }
+  isBOF() {
+    return this.currentIndex < 0;
+  }
+  isEOF() {
+    return this.currentIndex >= this.filteredRecords.length;
+  }
+  // =================== State Management ===================
+  isBrowsing() {
+    return this.state === "browse";
+  }
+  isEditing() {
+    return this.state === "edit";
+  }
+  isInserting() {
+    return this.state === "insert";
+  }
+  edit() {
+    if (this.validateDataSourceActive("edit"), this.isEmpty() || !this.getCurrentRecord()) {
+      const e = m.t("archbase:noRecordsToEdit", { dataSourceName: this.name });
+      throw this.publishEventError(e, {}), new g(e);
+    }
+    this.state = "edit", this.originalRecord = JSON.parse(JSON.stringify(this.getCurrentRecord())), this.emit({
+      type: d.beforeEdit,
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    }), this.emit({
+      type: d.afterEdit,
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    });
+  }
+  cancel() {
+    if (this.validateDataSourceActive("cancel"), this.state === "edit" && this.originalRecord) {
+      this.filteredRecords = [...this.filteredRecords], this.filteredRecords[this.currentIndex] = { ...this.originalRecord };
+      const e = this.service.getId(this.originalRecord), t = this.records.findIndex(
+        (r) => this.service.getId(r) === e
+      );
+      t >= 0 && (this.records = [...this.records], this.records[t] = { ...this.originalRecord });
+    } else
+      this.state === "insert" && (this.filteredRecords = this.filteredRecords.slice(0, -1), this.records = this.records.slice(0, -1), this.grandTotalRecords--, this.filteredRecords.length > 0 ? this.currentIndex = Math.min(this.currentIndex, this.filteredRecords.length - 1) : this.currentIndex = -1);
+    this.state = "browse", this.originalRecord = null, this.emit({
+      type: d.afterCancel,
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    });
+  }
+  insert(e) {
+    this.validateDataSourceActive("insert"), this.state = "insert", this.emit({
+      type: d.beforeInsert
+    }), this.filteredRecords = [...this.filteredRecords, e], this.records = [...this.records, e], this.currentIndex = this.filteredRecords.length - 1, this.grandTotalRecords++, this.notifyStateChange(), this.emit({
+      type: d.afterInsert,
+      record: e,
+      index: this.currentIndex
+    });
+  }
+  // =================== Remote CRUD Operations ===================
+  async save(e) {
+    if (this.validateDataSourceActive("save"), !this.isInserting() && !this.isEditing()) {
+      const r = m.t("archbase:saveRecordIsNotAllowed", { dataSourceName: this.name });
+      throw this.publishEventError(r, {}), new g(r);
+    }
+    if (!this.getCurrentRecord()) {
+      const r = m.t("archbase:noRecordToSave", { dataSourceName: this.name });
+      throw this.publishEventError(r, {}), new g(r);
+    }
+    const t = this.getCurrentRecord();
+    if (this.emit({
+      type: d.beforeSave,
+      record: t,
+      index: this.getCurrentIndex()
+    }), this.validator) {
+      const r = this.validator.validateEntity(t);
+      if (r && r.length > 0)
+        if (this.publishEventErrors(r), r[0].fieldName) {
+          const i = m.t("archbase:errorSavingRecord", { dataSourceName: this.label });
+          throw new g(i);
+        } else
+          throw new g(r[0].errorMessage);
+    }
+    try {
+      const r = await this.service.save(t);
+      this.filteredRecords = _(this.filteredRecords, (s) => {
+        s[this.currentIndex] = r;
+      });
+      let i = -1;
+      return this.records.forEach((s, o) => {
+        const c = this.service.getId(s), f = this.service.getId(t);
+        (s === t || c !== void 0 && c === f) && (i = o);
+      }), this.records = _(this.records, (s) => {
+        i >= 0 ? s[i] = r : s.push(r);
+      }), this.state = "browse", this.originalRecord = null, this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime(), this.notifyStateChange(), this.emit({
+        type: d.afterSave,
+        record: r,
+        index: this.getCurrentIndex()
+      }), e && e(), r;
+    } catch (r) {
+      throw this.handleSaveError(r, e), new g(k(r));
+    }
+  }
+  async remove(e) {
+    if (this.validateDataSourceActive("remove"), this.isInserting() || this.isEditing()) {
+      const i = m.t("archbase:removingRecordIsNotAllowed", { dataSourceName: this.name });
+      throw this.publishEventError(i, {}), new g(i);
+    }
+    if (this.isEmpty() || !this.getCurrentRecord()) {
+      const i = m.t("archbase:noRecordsToEdit", { dataSourceName: this.name });
+      throw this.publishEventError(i, {}), new g(i);
+    }
+    const t = this.getCurrentRecord(), r = this.currentIndex;
+    this.emit({
+      type: d.beforeRemove,
+      record: t,
+      index: r
+    });
+    try {
+      await this.service.delete(this.service.getId(t)), this.filteredRecords = this.filteredRecords.filter((s, o) => o !== this.currentIndex);
+      const i = this.records.findIndex(
+        (s) => this.service.getId(s) === this.service.getId(t)
+      );
+      return i >= 0 && (this.records = this.records.filter((s, o) => o !== i)), this.grandTotalRecords--, this.filteredRecords.length === 0 ? this.currentIndex = -1 : this.currentIndex >= this.filteredRecords.length && (this.currentIndex = this.filteredRecords.length - 1), this.lastDataBrowsingOn = (/* @__PURE__ */ new Date()).getTime(), this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime(), this.notifyStateChange(), this.emit({ type: d.afterScroll }), this.emit({
+        type: d.afterRemove,
+        record: t,
+        index: r
+      }), e && e(), t;
+    } catch (i) {
+      const s = k(i);
+      throw this.emit({
+        type: d.onError,
+        error: s,
+        originalError: i
+      }), e && e(s), new g(s);
+    }
+  }
+  // =================== Field Operations ===================
+  setFieldValue(e, t) {
+    if (this.validateDataSourceActive("setFieldValue"), !this.getCurrentRecord())
+      return;
+    const r = this.getFieldValue(e);
+    if (r === t)
+      return;
+    const i = [...this.filteredRecords];
+    if (this.filteredRecords = _(this.filteredRecords, (s) => {
+      const o = s[this.currentIndex];
+      o && this.setNestedValue(o, e, t);
+    }), this.state === "edit" || this.state === "insert") {
+      const s = this.getCurrentRecord() ? this.service.getId(this.getCurrentRecord()) : null;
+      if (s !== void 0) {
+        const o = this.records.findIndex(
+          (c) => this.service.getId(c) === s
+        );
+        o >= 0 && (this.records = _(this.records, (c) => {
+          this.setNestedValue(c[o], e, t);
+        }));
+      }
+    }
+    this.notifyStateChange(i), this.emit({
+      type: d.fieldChanged,
+      fieldName: e,
+      oldValue: r,
+      newValue: t,
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    }), this.emit({
+      type: d.dataChanged,
+      data: this.filteredRecords
+    });
+  }
+  getFieldValue(e) {
+    const t = this.getCurrentRecord();
+    if (t)
+      return this.getNestedValue(t, e);
+  }
+  // =================== Array Field Operations (V2) ===================
+  appendToFieldArray(e, t) {
+    if (this.validateDataSourceActive("appendToFieldArray"), !this.getCurrentRecord())
+      return;
+    const r = this.getFieldValue(e);
+    if (r == null) {
+      console.warn(`appendToFieldArray: Field ${String(e)} is undefined/null. Initialize the array in your DTO before using appendToFieldArray.`);
+      return;
+    }
+    if (!Array.isArray(r))
+      throw new Error(`Field ${String(e)} is not an array (found: ${typeof r})`);
+    const i = [...this.filteredRecords];
+    this.filteredRecords = _(this.filteredRecords, (s) => {
+      const o = s[this.currentIndex];
+      if (o) {
+        const c = this.getNestedValue(o, e);
+        c && c.push(t);
+      }
+    }), this.notifyStateChange(i), this.emit({
+      type: d.fieldChanged,
+      fieldName: e,
+      oldValue: r,
+      newValue: [...r, t],
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    });
+  }
+  updateFieldArrayItem(e, t, r) {
+    if (this.validateDataSourceActive("updateFieldArrayItem"), !this.getCurrentRecord())
+      return;
+    const i = this.getFieldValue(e);
+    if (!Array.isArray(i) || t < 0 || t >= i.length)
+      return;
+    const s = [...this.filteredRecords];
+    this.filteredRecords = _(this.filteredRecords, (o) => {
+      const c = o[this.currentIndex];
+      if (c) {
+        const f = this.getNestedValue(c, e);
+        f[t] !== void 0 && r(f[t]);
+      }
+    }), this.notifyStateChange(s), this.emit({
+      type: d.fieldChanged,
+      fieldName: e,
+      oldValue: i,
+      newValue: this.getFieldValue(e),
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    });
+  }
+  removeFromFieldArray(e, t) {
+    if (this.validateDataSourceActive("removeFromFieldArray"), !this.getCurrentRecord())
+      return;
+    const r = this.getFieldValue(e);
+    if (!Array.isArray(r))
+      throw new Error(`Field ${String(e)} is not an array`);
+    if (t < 0 || t >= r.length)
+      return;
+    const i = [...this.filteredRecords];
+    this.filteredRecords = _(this.filteredRecords, (s) => {
+      const o = s[this.currentIndex];
+      o && this.getNestedValue(o, e).splice(t, 1);
+    }), this.notifyStateChange(i), this.emit({
+      type: d.fieldChanged,
+      fieldName: e,
+      oldValue: r,
+      newValue: this.getFieldValue(e),
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    });
+  }
+  insertIntoFieldArray(e, t, r) {
+    if (this.validateDataSourceActive("insertIntoFieldArray"), !this.getCurrentRecord())
+      return;
+    const i = this.getFieldValue(e);
+    if (!Array.isArray(i))
+      throw new Error(`Field ${String(e)} is not an array`);
+    const s = [...this.filteredRecords];
+    this.filteredRecords = _(this.filteredRecords, (o) => {
+      const c = o[this.currentIndex];
+      c && this.getNestedValue(c, e).splice(t, 0, r);
+    }), this.notifyStateChange(s), this.emit({
+      type: d.fieldChanged,
+      fieldName: e,
+      oldValue: i,
+      newValue: this.getFieldValue(e),
+      record: this.getCurrentRecord(),
+      index: this.currentIndex
+    });
+  }
+  getFieldArray(e) {
+    const t = this.getFieldValue(e);
+    return t == null ? [] : Array.isArray(t) ? t : (console.warn(`Field ${String(e)} is not an array (found: ${typeof t}), returning empty array`), []);
+  }
+  isFieldArray(e) {
+    const t = this.getFieldValue(e);
+    return Array.isArray(t);
+  }
+  // =================== Remote Filter Operations ===================
+  /**
+   * Interface de opções para refreshData - compatibilidade com V1
+   */
+  currentPage = 0;
+  currentFilter;
+  currentSort;
+  /**
+   * Atualiza os dados do DataSource com as opções fornecidas.
+   * Compatível com a interface do DataSource V1.
+   *
+   * @param options Opções de refresh incluindo página, filtro e ordenação
+   */
+  refreshData(e) {
+    console.log("[V2 refreshData] Chamado com options:", e), e?.pageSize !== void 0 && (this.pageSize = e.pageSize);
+    const t = e?.currentPage ?? this.currentPage;
+    if (this.currentPage = t, console.log("[V2 refreshData] Página atual definida:", this.currentPage), "filter" in (e || {}) && (this.currentFilter = e?.filter, console.log("[V2 refreshData] Filtro definido:", this.currentFilter)), e?.sort !== void 0 && (this.currentSort = e.sort, this.defaultSortFields = e.sort.map((r) => r.split(":")[0])), this.currentFilter && this.currentFilter.trim() !== "") {
+      console.log("[V2 refreshData] Chamando getDataWithRsqlFilter para página:", t), this.getDataWithRsqlFilter(t);
+      return;
+    }
+    console.log("[V2 refreshData] Chamando getDataWithoutFilter para página:", t), this.getDataWithoutFilter(t);
+  }
+  /**
+   * Carrega dados com filtro RSQL
+   */
+  async getDataWithRsqlFilter(e, t) {
+    try {
+      let r;
+      return this.currentSort && this.currentSort.length > 0 ? r = await this.service.findAllWithFilterAndSort(
+        this.currentFilter,
+        e,
+        this.getPageSize(),
+        this.currentSort
+      ) : this.defaultSortFields.length > 0 ? r = await this.service.findAllWithFilterAndSort(
+        this.currentFilter,
+        e,
+        this.getPageSize(),
+        this.defaultSortFields
+      ) : r = await this.service.findAllWithFilter(
+        this.currentFilter,
+        e,
+        this.getPageSize()
+      ), r && r.content && (this.grandTotalRecords = r.totalElements || r.content.length, this.setRecords(r.content)), t && t(), r;
+    } catch (r) {
+      throw this.handleRemoteError(r, t), r;
+    }
+  }
+  /**
+   * Retorna as opções atuais do DataSource - compatibilidade com V1
+   */
+  getOptions() {
+    return {
+      currentPage: this.currentPage,
+      pageSize: this.pageSize,
+      filter: this.currentFilter,
+      sort: this.currentSort || this.defaultSortFields,
+      grandTotalRecords: this.grandTotalRecords
+    };
+  }
+  applyRemoteFilter(e, t, r) {
+    if (this.currentPage = t, !(e && e.filter)) {
+      this.getDataWithoutFilter(t, r);
+      return;
+    }
+    const s = e.filter.filterType, o = e.filter.quickFilterText;
+    s === Se && o && o !== "" ? this.getDataWithQuickFilter(e, t, r) : s === Fe || s === Ae ? this.getDataWithFilter(e, t, r) : this.getDataWithoutFilter(t, r);
+  }
+  // =================== Event Management ===================
+  addListener(e) {
+    this.listeners.add(e);
+  }
+  removeListener(e) {
+    this.listeners.delete(e);
+  }
+  emit(e) {
+    this.listeners.forEach((t) => {
+      try {
+        t(e);
+      } catch (r) {
+        console.error("Error in DataSource listener:", r);
+      }
+    });
+  }
+  // =================== Utility Methods ===================
+  getGrandTotalRecords() {
+    return this.grandTotalRecords;
+  }
+  getPageSize() {
+    return this.pageSize;
+  }
+  setPageSize(e) {
+    this.pageSize = e;
+  }
+  /**
+   * Retorna a página atual (0-indexed)
+   */
+  getCurrentPage() {
+    return this.currentPage;
+  }
+  /**
+   * Alias para getRecords - compatibilidade com V1
+   */
+  browseRecords() {
+    return [...this.filteredRecords];
+  }
+  getRecords() {
+    return [...this.filteredRecords];
+  }
+  /**
+   * Localiza um registro por valores de campos e navega para ele
+   * @param values Objeto com campos/valores para busca
+   * @returns true se encontrou, false caso contrário
+   */
+  locate(e) {
+    const t = Object.keys(e), r = this.filteredRecords.findIndex((i) => t.every((s) => {
+      const o = i[s], c = e[s];
+      return o === c;
+    }));
+    return r >= 0 ? (this.currentIndex = r, this.emit({
+      type: d.afterScroll
+    }), !0) : !1;
+  }
+  /**
+   * Vai para um registro pelo seu índice (alias para goToRecord)
+   * @param index Índice do registro
+   */
+  gotoRecord(e) {
+    this.goToRecord(e);
+  }
+  /**
+   * Vai para um registro pelo seu dado
+   * @param record Dados do registro para navegar
+   * @returns true se encontrou, false caso contrário
+   */
+  gotoRecordByData(e) {
+    const t = this.service.getId(e), r = this.filteredRecords.findIndex(
+      (i) => this.service.getId(i) === t
+    );
+    return r >= 0 ? (this.currentIndex = r, this.emit({
+      type: d.afterScroll
+    }), !0) : !1;
+  }
+  setRecords(e, t) {
+    const r = [...this.filteredRecords];
+    this.records = [...e], this.filteredRecords = [...e], t !== void 0 ? this.grandTotalRecords = t : this.grandTotalRecords < e.length && (this.grandTotalRecords = e.length), e.length > 0 ? this.currentIndex = 0 : this.currentIndex = -1, this.lastDataChangedAt = (/* @__PURE__ */ new Date()).getTime(), this.notifyStateChange(r), this.emit({
+      type: d.dataChanged,
+      data: this.filteredRecords
+    });
+  }
+  // =================== Debug Support ===================
+  getDebugSnapshot() {
+    return {
+      name: this.name,
+      label: this.label,
+      recordCount: this.filteredRecords.length,
+      currentIndex: this.currentIndex,
+      currentRecord: this.getCurrentRecord(),
+      state: this.state,
+      listeners: this.listeners.size,
+      totalRecords: this.grandTotalRecords,
+      pageSize: this.pageSize
+    };
+  }
+  // =================== Private Helper Methods ===================
+  validateDataSourceActive(e) {
+    if (!this.active)
+      throw new g(`DataSource ${this.name} is not active. Cannot perform ${e}`);
+  }
+  publishEventError(e, t) {
+    this.emit({
+      type: d.onError,
+      error: e,
+      originalError: t
+    }), this.onError && this.onError(e, t);
+  }
+  publishEventErrors(e) {
+    e.forEach((t) => {
+      t.fieldName && (this.emit({
+        type: d.onFieldError,
+        fieldName: t.fieldName,
+        error: t.errorMessage,
+        originalError: t
+      }), this.onFieldError && this.onFieldError(t.fieldName, t.errorMessage));
+    });
+  }
+  handleSaveError(e, t) {
+    e.response && e.response.data && e.response.data.apierror && e.response.data.apierror.subErrors && e.response.data.apierror.subErrors.forEach((i) => {
+      i.field && (this.emit({
+        type: d.onFieldError,
+        fieldName: i.field,
+        error: i.message,
+        originalError: i.message
+      }), this.onFieldError && this.onFieldError(i.field, i.message));
+    });
+    const r = k(e);
+    this.emit({
+      type: d.onError,
+      error: r,
+      originalError: e
+    }), this.onError && this.onError(r, e), t && t(r);
+  }
+  notifyStateChange(e) {
+    this.onStateChange && e && this.onStateChange(e, [...this.filteredRecords]);
+  }
+  setNestedValue(e, t, r) {
+    const i = t.split(".");
+    let s = e;
+    for (let o = 0; o < i.length - 1; o++) {
+      const c = i[o];
+      c in s || (s[c] = {}), s = s[c];
+    }
+    s[i[i.length - 1]] = r;
+  }
+  getNestedValue(e, t) {
+    const r = t.split(".");
+    let i = e;
+    for (const s of r) {
+      if (i == null)
+        return;
+      i = i[s];
+    }
+    return i;
+  }
+  // =================== Remote Data Loading ===================
+  async getDataWithFilter(e, t, r) {
+    try {
+      const i = new xe();
+      i.buildFrom(e.filter, e.sort);
+      const s = i.toJSON();
+      let o;
+      return s ? o = await this.service.findAllWithFilter(s, t, this.getPageSize()) : o = await this.getDataWithoutFilter(t), o && o.content && (this.grandTotalRecords = o.totalElements || o.content.length, this.setRecords(o.content)), r && r(), o;
+    } catch (i) {
+      throw this.handleRemoteError(i, r), i;
+    }
+  }
+  async getDataWithoutFilter(e, t) {
+    try {
+      console.log("[V2 getDataWithoutFilter] Buscando página:", e, "pageSize:", this.getPageSize(), "sort:", this.defaultSortFields);
+      let r;
+      return this.defaultSortFields.length > 0 ? r = await this.service.findAllWithSort(e, this.getPageSize(), this.defaultSortFields) : r = await this.service.findAll(e, this.getPageSize()), console.log("[V2 getDataWithoutFilter] Resultado:", r?.totalElements, "registros totais,", r?.content?.length, "na página"), r && r.content && (this.grandTotalRecords = r.totalElements || r.content.length, this.setRecords(r.content), console.log("[V2 getDataWithoutFilter] Após setRecords - currentPage:", this.currentPage, "grandTotal:", this.grandTotalRecords)), t && t(), r;
+    } catch (r) {
+      throw this.handleRemoteError(r, t), r;
+    }
+  }
+  async getDataWithQuickFilter(e, t, r) {
+    try {
+      const i = Array.isArray(e.filter.quickFilterFieldsText) ? e.filter.quickFilterFieldsText.join(",") : e.filter.quickFilterFieldsText, s = this.getSortFields(e).join(","), o = await this.service.findAllMultipleFields(
+        e.filter.quickFilterText,
+        i,
+        t,
+        this.getPageSize(),
+        s
+      );
+      return o && o.content && (this.grandTotalRecords = o.totalElements || o.content.length, this.setRecords(o.content)), r && r(), o;
+    } catch (i) {
+      throw this.handleRemoteError(i, r), i;
+    }
+  }
+  getSortFields(e) {
+    if (e && e.sort) {
+      const t = e.sort.quickFilterSort;
+      if (Array.isArray(t))
+        return t;
+      if (typeof t == "string")
+        return [t];
+    }
+    return this.defaultSortFields;
+  }
+  handleRemoteError(e, t) {
+    const r = k(e);
+    this.emit({
+      type: d.onError,
+      error: r,
+      originalError: e
+    }), this.onError && this.onError(r, e), t && t();
+  }
+}
+function be(n) {
+  const e = le(null), [t, r] = C(null), [i, s] = C(-1), [o, c] = C(0), [f, R] = C(!0), [b, N] = C(!1), [W, T] = C(!1), [O, $] = C(!1), [, z] = C({}), u = l(() => z({}), []), a = H(() => (e.current || (e.current = new U(n)), e.current), []), V = l((F) => {
+    switch (F.type) {
+      case d.dataChanged:
+      case d.recordChanged:
+        r(a.getCurrentRecord()), s(a.getCurrentIndex()), c(a.getTotalRecords()), R(a.isBrowsing()), N(a.isEditing()), T(a.isInserting());
+        break;
+      case d.fieldChanged:
+        r(a.getCurrentRecord()), u();
+        break;
+      case d.afterScroll:
+        r(a.getCurrentRecord()), s(a.getCurrentIndex());
+        break;
+      case d.beforeEdit:
+      case d.beforeInsert:
+        $(!0);
+        break;
+      case d.afterEdit:
+      case d.afterInsert:
+      case d.afterSave:
+      case d.afterCancel:
+        $(!1), R(a.isBrowsing()), N(a.isEditing()), T(a.isInserting());
+        break;
+      case d.onError:
+      case d.onFieldError:
+        $(!1);
+        break;
+    }
+  }, [a, u]);
+  J(() => (a.addListener(V), r(a.getCurrentRecord()), s(a.getCurrentIndex()), c(a.getTotalRecords()), R(a.isBrowsing()), N(a.isEditing()), T(a.isInserting()), () => {
+    a.removeListener(V);
+  }), [a, V]);
+  const Y = l((F, j) => {
+    a.setFieldValue(F, j);
+  }, [a]), S = l((F) => a.getFieldValue(F), [a]), h = l(() => {
+    a instanceof U, a.edit();
+  }, [a]), Q = l(async () => await a.save(), [a]), X = l(() => {
+    a instanceof U, a.cancel();
+  }, [a]), I = l((F) => {
+    a instanceof U, a.insert(F);
+  }, [a]), G = l(async (F) => await a.remove(F), [a]), Z = l(() => {
+    a instanceof U, a.first();
+  }, [a]), D = l(() => {
+    a instanceof U, a.last();
+  }, [a]), E = l(() => {
+    a instanceof U, a.next();
+  }, [a]), A = l(() => {
+    a instanceof U, a.prior();
+  }, [a]), P = l((F) => {
+    a instanceof U, a.goToRecord(F);
+  }, [a]), p = l((F, j) => {
+    a instanceof U && a.appendToFieldArray(F, j);
+  }, [a]), v = l((F, j, he) => {
+    a instanceof U && a.updateFieldArrayItem(F, j, he);
+  }, [a]), x = l((F, j) => {
+    a instanceof U && a.removeFromFieldArray(F, j);
+  }, [a]), L = l((F, j, he) => {
+    a instanceof U && a.insertIntoFieldArray(F, j, he);
+  }, [a]), y = l((F) => {
+    if (a instanceof U)
+      return a.getFieldArray(F);
+    const j = a.getFieldValue(F);
+    return Array.isArray(j) ? j : [];
+  }, [a]), q = l((F) => {
+    if (a instanceof U)
+      return a.isFieldArray(F);
+    const j = a.getFieldValue(F);
+    return Array.isArray(j);
+  }, [a]), te = H(() => i < o - 1, [i, o]), oe = H(() => i > 0, [i]), ae = H(() => o === 0, [o]), B = H(() => i === 0, [i]), K = H(() => i === o - 1, [i, o]), re = H(() => f, [f]), de = H(() => b, [b]), ce = H(() => W, [W]), fe = l(() => process.env.NODE_ENV === "development" ? {
+    ...a.getDebugSnapshot(),
+    hookState: {
+      currentRecord: t,
+      currentIndex: i,
+      totalRecords: o,
+      isBrowsing: re,
+      isEditing: de,
+      isInserting: ce,
+      isLoading: O
+    }
+  } : null, [a, t, i, o, re, de, ce, O]);
+  return {
+    // DataSource instance (para casos onde acesso direto é necessário)
+    dataSource: a,
+    // Estado reativo
+    currentRecord: t,
+    currentIndex: i,
+    totalRecords: o,
+    isLoading: O,
+    // Estado derivado
+    canNext: te,
+    canPrior: oe,
+    isEmpty: ae,
+    isFirst: B,
+    isLast: K,
+    isBrowsing: re,
+    isEditing: de,
+    isInserting: ce,
+    // Operações básicas
+    setFieldValue: Y,
+    getFieldValue: S,
+    edit: h,
+    save: Q,
+    cancel: X,
+    insert: I,
+    remove: G,
+    // Navegação
+    first: Z,
+    last: D,
+    next: E,
+    prior: A,
+    goToRecord: P,
+    // Operações de array (V2)
+    appendToFieldArray: p,
+    updateFieldArrayItem: v,
+    removeFromFieldArray: x,
+    insertIntoFieldArray: L,
+    getFieldArray: y,
+    isFieldArray: q,
+    // Debug
+    getDebugInfo: fe
+  };
+}
+function It(n) {
+  const {
+    dataSource: e,
+    currentRecord: t,
+    currentIndex: r,
+    totalRecords: i,
+    canNext: s,
+    canPrior: o,
+    isEmpty: c,
+    isFirst: f,
+    isLast: R,
+    isBrowsing: b,
+    first: N,
+    last: W,
+    next: T,
+    prior: O,
+    goToRecord: $,
+    getFieldValue: z,
+    getFieldArray: u,
+    isFieldArray: a
+  } = be(n);
+  return {
+    dataSource: e,
+    currentRecord: t,
+    currentIndex: r,
+    totalRecords: i,
+    canNext: s,
+    canPrior: o,
+    isEmpty: c,
+    isFirst: f,
+    isLast: R,
+    isBrowsing: b,
+    first: N,
+    last: W,
+    next: T,
+    prior: O,
+    goToRecord: $,
+    getFieldValue: z,
+    getFieldArray: u,
+    isFieldArray: a
+  };
+}
+function wt(n) {
+  return be(n);
+}
+function De(n) {
+  const e = le(null), [t, r] = C(void 0), [i, s] = C(-1), [o, c] = C(0), [f, R] = C(0), [b, N] = C(!0), [W, T] = C(!1), [O, $] = C(!1), [z, u] = C(!1), [a, V] = C(null), [, Y] = C({}), S = l(() => Y({}), []), h = H(() => (e.current || (e.current = new Je(n)), e.current), []), Q = l((w) => {
+    switch (w.type) {
+      case d.dataChanged:
+      case d.recordChanged:
+      case d.refreshData:
+        r(h.getCurrentRecord()), s(h.getCurrentIndex()), c(h.getTotalRecords()), R(h.getGrandTotalRecords()), N(h.isBrowsing()), T(h.isEditing()), $(h.isInserting()), u(!1), V(null);
+        break;
+      case d.fieldChanged:
+        r(h.getCurrentRecord()), S();
+        break;
+      case d.afterScroll:
+        r(h.getCurrentRecord()), s(h.getCurrentIndex());
+        break;
+      case d.beforeEdit:
+      case d.beforeInsert:
+      case d.beforeSave:
+      case d.beforeRemove:
+        u(!0), V(null);
+        break;
+      case d.afterEdit:
+      case d.afterInsert:
+      case d.afterSave:
+      case d.afterCancel:
+      case d.afterRemove:
+        u(!1), N(h.isBrowsing()), T(h.isEditing()), $(h.isInserting()), V(null);
+        break;
+      case d.onError:
+        u(!1), V(w.error);
+        break;
+      case d.onFieldError:
+        u(!1);
+        break;
+    }
+  }, [h, S]);
+  J(() => (h.addListener(Q), r(h.getCurrentRecord()), s(h.getCurrentIndex()), c(h.getTotalRecords()), R(h.getGrandTotalRecords()), N(h.isBrowsing()), T(h.isEditing()), $(h.isInserting()), () => {
+    h.removeListener(Q);
+  }), [h, Q]);
+  const X = l((w, M) => {
+    h.setFieldValue(w, M);
+  }, [h]), I = l((w) => h.getFieldValue(w), [h]), G = l(() => {
+    h.edit();
+  }, [h]), Z = l(async () => {
+    try {
+      return V(null), await h.save();
+    } catch (w) {
+      throw V(w.message || "Erro ao salvar"), w;
+    }
+  }, [h]), D = l(() => {
+    h.cancel();
+  }, [h]), E = l((w) => {
+    h.insert(w);
+  }, [h]), A = l(async (w) => {
+    try {
+      return V(null), await h.remove(w);
+    } catch (M) {
+      throw V(M.message || "Erro ao remover"), M;
+    }
+  }, [h]), P = l(() => {
+    h.first();
+  }, [h]), p = l(() => {
+    h.last();
+  }, [h]), v = l(() => {
+    h.next();
+  }, [h]), x = l(() => {
+    h.prior();
+  }, [h]), L = l((w) => {
+    h.goToRecord(w);
+  }, [h]), y = l((w, M) => {
+    h.appendToFieldArray(w, M);
+  }, [h]), q = l((w, M, se) => {
+    h.updateFieldArrayItem(w, M, se);
+  }, [h]), te = l((w, M) => {
+    h.removeFromFieldArray(w, M);
+  }, [h]), oe = l((w, M, se) => {
+    h.insertIntoFieldArray(w, M, se);
+  }, [h]), ae = l((w) => h.getFieldArray(w), [h]), B = l((w) => h.isFieldArray(w), [h]), K = l((w, M, se) => {
+    u(!0), V(null);
+    try {
+      h.applyRemoteFilter(w, M, () => {
+        u(!1), se && se();
+      });
+    } catch (Pe) {
+      u(!1), V(Pe.message || "Erro ao aplicar filtro");
+    }
+  }, [h]), re = l(async (w) => {
+    try {
+      u(!0), V(null), h.refreshData(w);
+    } catch (M) {
+      throw u(!1), V(M.message || "Erro ao atualizar dados"), M;
+    }
+  }, [h]), de = l((w) => {
+    h.setPageSize(w);
+  }, [h]), ce = l(() => h.getPageSize(), [h]), fe = H(() => i < o - 1, [i, o]), F = H(() => i > 0, [i]), j = H(() => o === 0, [o]), he = H(() => i === 0, [i]), Te = H(() => i === o - 1, [i, o]), me = H(() => b, [b]), Re = H(() => W, [W]), pe = H(() => O, [O]), Oe = l(() => process.env.NODE_ENV === "development" ? {
+    ...h.getDebugSnapshot(),
+    hookState: {
+      currentRecord: t,
+      currentIndex: i,
+      totalRecords: o,
+      grandTotalRecords: f,
+      isBrowsing: me,
+      isEditing: Re,
+      isInserting: pe,
+      isLoading: z,
+      error: a
+    }
+  } : null, [h, t, i, o, f, me, Re, pe, z, a]);
+  return {
+    // DataSource instance (para casos onde acesso direto é necessário)
+    dataSource: h,
+    // Estado reativo
+    currentRecord: t,
+    currentIndex: i,
+    totalRecords: o,
+    grandTotalRecords: f,
+    isLoading: z,
+    error: a,
+    // Estado derivado
+    canNext: fe,
+    canPrior: F,
+    isEmpty: j,
+    isFirst: he,
+    isLast: Te,
+    isBrowsing: me,
+    isEditing: Re,
+    isInserting: pe,
+    // Operações básicas
+    setFieldValue: X,
+    getFieldValue: I,
+    edit: G,
+    save: Z,
+    cancel: D,
+    insert: E,
+    remove: A,
+    // Navegação
+    first: P,
+    last: p,
+    next: v,
+    prior: x,
+    goToRecord: L,
+    // Operações de array (V2)
+    appendToFieldArray: y,
+    updateFieldArrayItem: q,
+    removeFromFieldArray: te,
+    insertIntoFieldArray: oe,
+    getFieldArray: ae,
+    isFieldArray: B,
+    // Operações remotas
+    applyRemoteFilter: K,
+    refreshData: re,
+    setPageSize: de,
+    getPageSize: ce,
+    // Debug
+    getDebugInfo: Oe
+  };
+}
+function Et(n) {
+  const {
+    dataSource: e,
+    currentRecord: t,
+    currentIndex: r,
+    totalRecords: i,
+    grandTotalRecords: s,
+    isLoading: o,
+    error: c,
+    canNext: f,
+    canPrior: R,
+    isEmpty: b,
+    isFirst: N,
+    isLast: W,
+    isBrowsing: T,
+    first: O,
+    last: $,
+    next: z,
+    prior: u,
+    goToRecord: a,
+    getFieldValue: V,
+    getFieldArray: Y,
+    isFieldArray: S,
+    applyRemoteFilter: h,
+    refreshData: Q,
+    getPageSize: X,
+    getDebugInfo: I
+  } = De(n);
+  return {
+    dataSource: e,
+    currentRecord: t,
+    currentIndex: r,
+    totalRecords: i,
+    grandTotalRecords: s,
+    isLoading: o,
+    error: c,
+    canNext: f,
+    canPrior: R,
+    isEmpty: b,
+    isFirst: N,
+    isLast: W,
+    isBrowsing: T,
+    first: O,
+    last: $,
+    next: z,
+    prior: u,
+    goToRecord: a,
+    getFieldValue: V,
+    getFieldArray: Y,
+    isFieldArray: S,
+    applyRemoteFilter: h,
+    refreshData: Q,
+    getPageSize: X,
+    getDebugInfo: I
+  };
+}
+function St(n) {
+  return De(n);
+}
+class Ft {
+  /**
+   * Gera chave de query baseada no DataSource e filtros
+   */
+  static generateQueryKey(e, t, r, i) {
+    const s = ["archbase-datasource", e];
+    return t && s.push("filter", JSON.stringify(t)), r && s.push("sort", JSON.stringify(r)), i !== void 0 && s.push("page", i.toString()), s;
+  }
+  /**
+   * Determina se os dados precisam ser refetch baseado em critérios
+   */
+  static shouldRefetch(e, t, r = !1) {
+    const i = Date.now(), s = i - e > t;
+    return !!(r && s || i - e > t * 2);
+  }
+  /**
+   * Merge optimistic updates com dados em cache
+   */
+  static mergeOptimisticUpdate(e, t, r) {
+    return e.map(
+      (i) => i[r] === t[r] ? { ...i, ...t } : i
+    );
+  }
+}
+const At = {
+  /** Configuração para dados que mudam raramente */
+  STATIC_DATA: {
+    staleTime: 30 * 60 * 1e3,
+    // 30 minutos
+    cacheTime: 60 * 60 * 1e3,
+    // 1 hora
+    refetchOnWindowFocus: !1,
+    retry: 1
+  },
+  /** Configuração para dados dinâmicos */
+  DYNAMIC_DATA: {
+    staleTime: 5 * 60 * 1e3,
+    // 5 minutos
+    cacheTime: 15 * 60 * 1e3,
+    // 15 minutos
+    refetchOnWindowFocus: !0,
+    retry: 3
+  },
+  /** Configuração para dados em tempo real */
+  REALTIME_DATA: {
+    staleTime: 30 * 1e3,
+    // 30 segundos
+    cacheTime: 5 * 60 * 1e3,
+    // 5 minutos
+    refetchOnWindowFocus: !0,
+    refetchInterval: 60 * 1e3,
+    // 1 minuto
+    retry: 5
+  }
+}, xt = (n) => {
+  const { initialData: e, name: t, label: r, initialDataSource: i, onLoadComplete: s, store: o, validator: c } = n, f = () => o && o.existsValue(t) ? o.getValue(t) : i || new Ie(t, {
+    records: e,
+    grandTotalRecords: e.length,
+    currentPage: 0,
+    totalPages: 0,
+    pageSize: 0,
+    validator: c
+  }, r), [R, b] = C(
+    f()
+  );
+  return J(() => {
+    o && o.setValue(t, R), s && s(R);
+  }, [t]), { dataSource: R };
+}, Ct = (n) => {
+  const e = (r) => {
+    r.addListener(n.listener);
+  }, t = (r) => {
+    r.removeListener(n.listener);
+  };
+  J(() => (n.dataSource && (t(n.dataSource), e(n.dataSource)), () => {
+    n.dataSource && t(n.dataSource);
+  }), [n.dataSource?.uuid || n.dataSource?.getName()]);
+}, bt = (n) => {
+  const { initialData: e, name: t, initialDataSource: r, onLoadComplete: i, validator: s } = n, [o, c] = C(
+    r ?? new ke(t, {
+      records: e,
+      grandTotalRecords: e.length,
+      currentPage: 0,
+      totalPages: 0,
+      pageSize: 0,
+      validator: s
+    })
+  );
+  return J(() => {
+    c((f) => {
+      const R = {
+        records: e,
+        grandTotalRecords: e.length,
+        totalPages: 0,
+        currentPage: 0,
+        pageSize: 0,
+        validator: s
+      };
+      return f.isActive() ? f.setData(R) : f.open(R), f;
+    }), i && i(o);
+  }, [e, t]), { dataSource: o };
+};
+class Ve {
+  tokenManager;
+  constructor(e) {
+    this.tokenManager = e;
+  }
+  prepareHeaders(e = {}, t = !1) {
+    let r = { "Content-Type": "application/json; charset=utf-8", ...e };
+    if (!t) {
+      const i = this.tokenManager.getToken();
+      i && (r.Authorization = `Bearer ${i.access_token}`);
+    }
+    return r;
+  }
+  async get(e, t, r, i) {
+    try {
+      const s = this.prepareHeaders(t, r), o = await ee.get(e, { headers: s, ...i });
+      return ie.convertJsonToObject(o.data);
+    } catch (s) {
+      return Promise.reject(s);
+    }
+  }
+  async post(e, t, r, i, s) {
+    try {
+      const o = this.prepareHeaders(r, i), c = await ee.post(
+        e,
+        ie.convertObjectToJson(t),
+        {
+          headers: o,
+          ...s
+        }
+      );
+      return ie.convertJsonToObject(c.data);
+    } catch (o) {
+      return Promise.reject(o);
+    }
+  }
+  async postNoConvertId(e, t, r, i, s) {
+    try {
+      const o = this.prepareHeaders(r, i);
+      return (await ee.post(
+        e,
+        t,
+        {
+          headers: o,
+          ...s
+        }
+      )).data;
+    } catch (o) {
+      return Promise.reject(o);
+    }
+  }
+  async put(e, t, r, i, s) {
+    try {
+      const o = this.prepareHeaders(r, i), c = await ee.put(e, ie.convertObjectToJson(t), {
+        headers: o,
+        ...s
+      });
+      return ie.convertJsonToObject(c.data);
+    } catch (o) {
+      return Promise.reject(o);
+    }
+  }
+  async putNoConvertId(e, t, r, i, s) {
+    try {
+      const o = this.prepareHeaders(r, i);
+      return (await ee.put(e, t, {
+        headers: o,
+        ...s
+      })).data;
+    } catch (o) {
+      return Promise.reject(o);
+    }
+  }
+  async binaryPut(e, t, r = {}, i, s) {
+    try {
+      const o = this.prepareHeaders(r, i);
+      return s = s || {}, (await ee.put(e, t, {
+        headers: o,
+        ...s
+      })).data;
+    } catch (o) {
+      return Promise.reject(o);
+    }
+  }
+  async delete(e, t, r, i) {
+    try {
+      const s = this.prepareHeaders(t, r), o = await ee.delete(e, { headers: s, ...i });
+      return ie.convertJsonToObject(o.data);
+    } catch (s) {
+      return Promise.reject(s);
+    }
+  }
+  async patch(e, t, r, i, s) {
+    try {
+      const o = this.prepareHeaders(r, i), c = await ee.patch(e, ie.convertObjectToJson(t), {
+        headers: o,
+        ...s
+      });
+      return ie.convertJsonToObject(c.data);
+    } catch (o) {
+      return Promise.reject(o);
+    }
+  }
+  async patchNoConvertId(e, t, r, i, s) {
+    try {
+      const o = this.prepareHeaders(r, i);
+      return (await ee.patch(e, t, {
+        headers: o,
+        ...s
+      })).data;
+    } catch (o) {
+      return Promise.reject(o);
+    }
+  }
+}
+ne.decorate(ne.inject(He.TokenManager), Ve, 0);
+ne.decorate(ne.injectable(), Ve);
+class Qe {
+  client;
+  constructor(e) {
+    this.client = e;
+  }
+  transformPage(e) {
+    if (e.content && e.content.length > 0)
+      for (let t = 0; t < e.content.length; t++) {
+        const r = e.content[t];
+        this.isTransformable() && (e.content[t] = this.transform(r));
+      }
+  }
+  transformList(e) {
+    if (e && e.length > 0)
+      for (let t = 0; t < e.length; t++) {
+        const r = e[t];
+        this.isTransformable() && (e[t] = this.transform(r));
+      }
+  }
+  isTransformable() {
+    return typeof this.transform == "function";
+  }
+  async validate(e) {
+    const t = this.configureHeaders();
+    return this.client.post(`${this.getEndpoint()}/validate`, e, t, !1);
+  }
+  async validateGroup(e, t) {
+    const r = { groups: JSON.stringify(t) }, i = this.configureHeaders(), s = { ...r, ...i };
+    return this.client.post(`${this.getEndpoint()}/validateGroup`, e, s, !1);
+  }
+  async exists(e) {
+    const t = this.configureHeaders();
+    return this.client.get(`${this.getEndpoint()}/exists/${e}`, t, !1);
+  }
+  async findAll(e, t) {
+    const r = this.configureHeaders(), i = await this.client.get(`${this.getEndpoint()}/findAll?page=${e}&size=${t}`, r, !1);
+    return this.transformPage(i), i;
+  }
+  async findAllWithSort(e, t, r) {
+    const i = this.configureHeaders(), s = await this.client.get(
+      `${this.getEndpoint()}/findAll?page=${e}&size=${t}&sort=${r}`,
+      i,
+      !1
+    );
+    return this.transformPage(s), s;
+  }
+  async findAllByIds(e) {
+    const t = this.configureHeaders(), r = await this.client.get(`${this.getEndpoint()}/findAll?ids=${e}`, t, !1);
+    return this.transformList(r), r;
+  }
+  async findAllWithFilter(e, t, r) {
+    const i = this.configureHeaders(), s = await this.client.get(
+      `${this.getEndpoint()}/findWithFilter?page=${t}&size=${r}&filter=${encodeURIComponent(
+        e
+      )}`,
+      i,
+      !1
+    );
+    return this.transformPage(s), s;
+  }
+  async findAllMultipleFields(e, t, r, i, s) {
+    const o = this.configureHeaders(), c = await this.client.get(
+      `${this.getEndpoint()}/findMultipleFields?page=${r}&size=${i}&fields=${encodeURIComponent(
+        t
+      )}&filter=${encodeURIComponent(e)}&sort=${encodeURIComponent(s)}`,
+      o,
+      !1
+    );
+    return this.transformPage(c), c;
+  }
+  async findAllWithFilterAndSort(e, t, r, i) {
+    const s = this.configureHeaders(), o = `${this.getEndpoint()}/findWithFilterAndSort?page=${t}&size=${r}&filter=${encodeURIComponent(
+      e
+    )}&sort=${i}`;
+    console.log("[findAllWithFilterAndSort] URL:", o), console.log("[findAllWithFilterAndSort] filter original:", e);
+    const c = await this.client.get(o, s, !1);
+    return this.transformPage(c), c;
+  }
+  async findOne(e) {
+    const t = this.configureHeaders(), r = await this.client.get(`${this.getEndpoint()}/${e}`, t, !1);
+    return this.isTransformable() ? this.transform(r) : r;
+  }
+  async findByComplexId(e) {
+    const t = this.configureHeaders();
+    return this.client.post(`${this.getEndpoint()}`, e, t, !1);
+  }
+  async existsByComplexId(e) {
+    const t = this.configureHeaders();
+    return this.client.post(`${this.getEndpoint()}`, e, t, !1);
+  }
+  async save(e) {
+    const t = this.configureHeaders();
+    let r;
+    return this.isNewRecord(e) ? r = await this.client.post(this.getEndpoint(), e, t, !1) : r = await this.client.put(`${this.getEndpoint()}/${e.id}`, e, t, !1), this.isTransformable() ? this.transform(r) : r;
+  }
+  async delete(e) {
+    const t = this.configureHeaders();
+    return this.client.delete(`${this.getEndpoint()}/${e}`, t, !1);
+  }
+}
+ne.decorate(ne.injectable(), Qe);
+class ge {
+  content;
+  pageable;
+  totalElements;
+  totalPages;
+  last;
+  sort;
+  number;
+  size;
+  first;
+  numberOfElements;
+  empty;
+  constructor(e, t, r, i, s, o, c, f, R, b) {
+    this.content = e, this.totalElements = t, this.totalPages = r, this.number = i, this.size = s, this.sort = o || { sorted: !1, unsorted: !0, empty: !0 }, this.last = c !== void 0 ? c : i === r - 1, this.first = f !== void 0 ? f : i === 0, this.numberOfElements = R !== void 0 ? R : e.length, this.empty = b !== void 0 ? b : e.length === 0, this.pageable = {
+      sort: this.sort,
+      offset: i * s,
+      pageSize: s,
+      pageNumber: i,
+      unpaged: !1,
+      paged: !0
+    };
+  }
+  static createFromValues(e, t, r, i, s) {
+    return new ge(e, t, r, i, s);
+  }
+}
+function Ke(n) {
+  return n.totalElements || n.totalElements === 0 ? n.totalElements : n.page.totalElements;
+}
+function Ye(n) {
+  return n.totalPages || n.totalPages === 0 ? n.totalPages : n.page.totalPages;
+}
+function Xe(n) {
+  return n.pageable ? n.pageable.pageNumber : n.page.number;
+}
+function Dt(n) {
+  const {
+    name: e,
+    label: t,
+    service: r,
+    filter: i,
+    sort: s,
+    transformData: o,
+    onLoadComplete: c,
+    onDestroy: f,
+    filterData: R,
+    findAll: b,
+    findAllWithSort: N,
+    findAllWithFilter: W,
+    findAllWithFilterAndSort: T,
+    initialDataSource: O,
+    pageSize: $ = 50,
+    currentPage: z = 0,
+    loadOnStart: u = !0,
+    store: a,
+    id: V,
+    validator: Y
+  } = n, S = le(!1), h = () => !!(a && a.existsValue(e) || O), Q = () => a && a.existsValue(e) ? a.getValue(e) : O || new Ce(r, e, {
+    records: [],
+    grandTotalRecords: 0,
+    currentPage: z,
+    totalPages: 0,
+    pageSize: $,
+    validator: Y
+  }, t), X = () => a && a.existsValue(e) ? a.getValue(e).getCurrentPage() : O ? O.getCurrentPage() : 0, [I, G] = C({
+    dataSource: Q(),
+    isLoading: !1,
+    isError: !1,
+    error: "",
+    name: e,
+    label: t,
+    filter: i,
+    sort: s,
+    id: V,
+    currentPage: X(),
+    pageSize: $,
+    loadDataCount: h() ? 1 : 0
+  }), Z = async (p, v, x, L, y, q, te, oe, ae) => {
+    let B;
+    if (q) {
+      const K = await r.findOne(q);
+      K ? B = ge.createFromValues([K], 1, 0, 0, 0) : B = ge.createFromValues([], 0, 0, 0, 0);
+    } else
+      T && L && y && y.length > 0 ? B = await T(L, v, x, y) : W && L ? B = await W(L, v, x) : N && y && y.length > 0 ? B = await N(v, x, y) : b ? B = await b(v, x) : L && y && y.length > 0 ? B = await r.findAllWithFilterAndSort(L, v, x, y) : L ? B = await r.findAllWithFilter(L, v, x) : y && y.length > 0 ? B = await r.findAllWithSort(v, x, y) : B = await r.findAll(v, x);
+    R && (B = R(B)), o && (B = o(B)), G((K) => {
+      const re = {
+        records: B.content,
+        grandTotalRecords: Ke(B),
+        totalPages: Ye(B),
+        currentPage: Xe(B),
+        pageSize: x,
+        filter: L,
+        sort: y,
+        originFilter: te,
+        originGlobalFilter: ae,
+        originSort: oe,
+        validator: Y
+      };
+      return K.dataSource.isActive() ? K.dataSource.setData(re) : K.dataSource.open(re), {
+        ...K,
+        currentPage: v,
+        pageSize: x,
+        filter: L,
+        sort: y,
+        id: q,
+        isLoading: !1,
+        isError: !1,
+        error: "",
+        loadDataCount: K.loadDataCount + 1
+      };
+    }), a && a.setValue(e, I.dataSource);
+  };
+  J(() => {
+    c && I.loadDataCount > 0 && c(I.dataSource);
+  }, [I.loadDataCount]);
+  const D = l((p) => {
+    if (p.type === d.refreshData) {
+      const v = p.options;
+      try {
+        G((x) => ({
+          ...x,
+          isLoading: !0,
+          filter: v.filter,
+          sort: v.sort,
+          currentPage: v.currentPage,
+          id: v.id
+        })), Z(
+          I.name,
+          v.currentPage,
+          v.pageSize,
+          v.filter,
+          v.sort,
+          v.id,
+          v.originFilter,
+          v.originSort,
+          v.originGlobalFilter
+        ).catch((x) => {
+          const L = k(x);
+          G((y) => ({
+            ...y,
+            isError: !0,
+            isLoading: !1,
+            error: L
+          })), n.onError && n.onError(L, x);
+        });
+      } catch (x) {
+        const L = k(x);
+        G((y) => ({
+          ...y,
+          isError: !0,
+          isLoading: !1,
+          error: L
+        })), n.onError && n.onError(L, x);
+      }
+    }
+  }, [Z, I.name, n.onError]), E = l((p) => {
+    S.current || (p.addListener(D), S.current = !0);
+  }, [D]), A = l((p) => {
+    S.current && (p.removeListener(D), S.current = !1);
+  }, [D]);
+  J(() => {
+    try {
+      return E(I.dataSource), u && I.loadDataCount === 0 ? (G((p) => ({ ...p, isLoading: !0 })), Z(
+        I.name,
+        z,
+        $,
+        I.filter,
+        I.sort,
+        I.id
+      ).catch((p) => {
+        const v = k(p);
+        G((x) => ({
+          ...x,
+          isError: !0,
+          isLoading: !1,
+          error: v
+        })), n.onError && n.onError(v, p);
+      })) : c && c(I.dataSource), () => {
+        f && (A(I.dataSource), f(I.dataSource));
+      };
+    } catch (p) {
+      const v = k(p);
+      G((x) => ({
+        ...x,
+        isError: !0,
+        isLoading: !1,
+        error: v
+      })), n.onError && n.onError(v, p);
+    }
+  }, [
+    I.name,
+    I.sort,
+    I.filter,
+    I.id,
+    I.currentPage,
+    I.pageSize
+  ]);
+  const P = () => {
+    G((p) => ({
+      ...p,
+      isError: !1,
+      isLoading: !1,
+      error: ""
+    }));
+  };
+  return {
+    isLoading: I.isLoading,
+    isError: I.isError,
+    error: I.error,
+    dataSource: I.dataSource,
+    clearError: P
+  };
+}
+function Ze(n) {
+  return n.totalElements || n.totalElements === 0 ? n.totalElements : n.page.totalElements;
+}
+function et(n) {
+  return n.totalPages || n.totalPages === 0 ? n.totalPages : n.page.totalPages;
+}
+function tt(n) {
+  return n.pageable ? n.pageable.pageNumber : n.page.number;
+}
+function Vt(n) {
+  const {
+    name: e,
+    service: t,
+    filter: r,
+    sort: i,
+    transformData: s,
+    onLoadComplete: o,
+    onDestroy: c,
+    filterData: f,
+    findAll: R,
+    findAllWithSort: b,
+    findAllWithFilter: N,
+    findAllWithFilterAndSort: W,
+    initialDataSource: T,
+    pageSize: O = 50,
+    currentPage: $ = 0,
+    loadOnStart: z = !0,
+    store: u,
+    validator: a
+  } = n, V = () => !!(u && u.existsValue(e) || T), Y = () => u && u.existsValue(e) ? u.getValue(e) : T || new _e(t, e, {
+    records: [],
+    grandTotalRecords: 0,
+    currentPage: $,
+    totalPages: 0,
+    pageSize: O,
+    validator: a
+  }), [S, h] = C({
+    dataSource: Y(),
+    isLoading: !1,
+    isError: !1,
+    error: "",
+    name: e,
+    filter: r,
+    sort: i,
+    currentPage: $,
+    pageSize: O,
+    loadDataCount: V() ? 1 : 0
+  }), Q = async (D, E, A, P, p, v, x, L) => {
+    let y;
+    W && P && p && p.length > 0 ? y = await W(P, E, A, p) : N && P ? y = await N(P, E, A) : b && p && p.length > 0 ? y = await b(E, A, p) : R ? y = await R(E, A) : P && p && p.length > 0 ? y = await t.findAllWithFilterAndSort(P, E, A, p) : P ? y = await t.findAllWithFilter(P, E, A) : p && p.length > 0 ? y = await t.findAllWithSort(E, A, p) : y = await t.findAll(E, A), f && (y = f(y)), s && (y = s(y)), h((q) => {
+      const te = {
+        records: y.content,
+        grandTotalRecords: Ze(y),
+        totalPages: et(y),
+        currentPage: tt(y),
+        pageSize: A,
+        filter: P,
+        sort: p,
+        originFilter: v,
+        originGlobalFilter: L,
+        originSort: x,
+        validator: a
+      };
+      return q.dataSource.isActive() ? q.dataSource.setData(te) : q.dataSource.open(te), {
+        ...q,
+        currentPage: E,
+        pageSize: A,
+        filter: P,
+        sort: p,
+        isLoading: !1,
+        isError: !1,
+        error: "",
+        loadDataCount: q.loadDataCount + 1
+      };
+    }), u && u.setValue(e, S.dataSource), o && o(S.dataSource);
+  }, X = (D) => {
+    if (D.type === d.refreshData) {
+      const E = D.options;
+      try {
+        h((A) => ({
+          ...A,
+          isLoading: !0,
+          filter: E.filter,
+          sort: E.sort,
+          currentPage: E.currentPage
+        })), Q(
+          S.name,
+          E.currentPage,
+          E.pageSize,
+          E.filter,
+          E.sort,
+          E.originFilter,
+          E.originSort,
+          E.originGlobalFilter
+        ).catch((A) => {
+          const P = k(A);
+          h((p) => ({
+            ...p,
+            isError: !0,
+            isLoading: !1,
+            error: P
+          })), n.onError && n.onError(P, A);
+        });
+      } catch (A) {
+        const P = k(A);
+        h((p) => ({
+          ...p,
+          isError: !0,
+          isLoading: !1,
+          error: P
+        })), n.onError && n.onError(P, A);
+      }
+    }
+  }, I = (D) => {
+    D.addListener(X);
+  }, G = (D) => {
+    D.removeListener(X);
+  };
+  J(() => {
+    try {
+      return I(S.dataSource), z && S.loadDataCount === 0 && (h((D) => ({ ...D, isLoading: !0 })), Q(
+        S.name,
+        $,
+        O,
+        S.filter,
+        S.sort
+      ).catch((D) => {
+        const E = k(D);
+        h((A) => ({
+          ...A,
+          isError: !0,
+          isLoading: !1,
+          error: E
+        })), n.onError && n.onError(E, D);
+      })), () => {
+        c && (G(S.dataSource), c(S.dataSource));
+      };
+    } catch (D) {
+      const E = k(D);
+      h((A) => ({
+        ...A,
+        isError: !0,
+        isLoading: !1,
+        error: E
+      })), n.onError && n.onError(E, D);
+    }
+  }, [
+    S.name,
+    S.sort,
+    S.filter,
+    S.currentPage,
+    S.pageSize
+  ]);
+  const Z = () => {
+    h((D) => ({
+      ...D,
+      isError: !1,
+      isLoading: !1,
+      error: ""
+    }));
+  };
+  return {
+    isLoading: S.isLoading,
+    isError: S.isError,
+    error: S.error,
+    dataSource: S.dataSource,
+    clearError: Z
+  };
+}
+function Tt(n) {
+  return ze((e) => e.get(n));
+}
+function Ot(n) {
+  J(() => {
+    n();
+  }, []);
+}
+function Pt(n, e) {
+  J(() => {
+    n();
+  }, e);
+}
+function Lt(n) {
+  J(() => () => {
+    n();
+  }, []);
+}
+function Bt() {
+  const [, n] = C(0);
+  return l(() => {
+    n((t) => t + 1);
+  }, []);
+}
+const rt = (n) => (n + 1) % 1e6;
+function it() {
+  const [, n] = We(rt, 0);
+  return n;
+}
+function $t() {
+  return it();
+}
+const st = Me((n, e) => ({
+  values: /* @__PURE__ */ new Map(),
+  setValue: (t, r) => n((i) => {
+    const s = new Map(i.values);
+    return s.set(t, r), { values: s };
+  }),
+  getValue: (t) => e().values.get(t),
+  existsValue: (t) => e().values.has(t),
+  clearValue: (t) => n((r) => {
+    const i = new Map(r.values);
+    return i.delete(t), { values: i };
+  }),
+  clearAllValues: () => n((t) => ({ values: /* @__PURE__ */ new Map() })),
+  reset: () => n((t) => ({ values: /* @__PURE__ */ new Map() }))
+})), nt = je(st), Nt = (n = "default") => {
+  const e = nt();
+  return { setValue: (R, b) => {
+    e.setValue(`${n}.${R}`, b);
+  }, getValue: (R) => e.getValue(`${n}.${R}`), clearValue: (R) => {
+    e.clearValue(`${n}.${R}`);
+  }, existsValue: (R) => e.existsValue(`${n}.${R}`), clearAllValues: () => {
+    for (const [R, b] of e.values.entries())
+      R.startsWith(`${n}.`) && e.clearValue(R);
+  }, reset: () => {
+    e.clearAllValues();
+  }, values: e.values };
+};
+function Ht(n, e, t = window) {
+  const r = le(e);
+  J(() => {
+    r.current = e;
+  }, [e]), J(
+    () => {
+      if (t && t.addEventListener && r.current) {
+        const s = (o) => r.current(o);
+        return t.addEventListener(n, s), () => {
+          t.removeEventListener(n, s);
+        };
+      }
+    },
+    [n, t]
+    // Executa novamente se eventName ou elemento mudar
+  );
+}
+export {
+  Mt as ADVANCED,
+  jt as ARCHBASE_IOC_API_TYPE,
+  At as ARCHBASE_QUERY_DEFAULTS,
+  Ve as ArchbaseAxiosRemoteApiClient,
+  Ie as ArchbaseDataSource,
+  U as ArchbaseDataSourceV2,
+  ke as ArchbaseLocalFilterDataSource,
+  Ft as ArchbaseQueryUtils,
+  Qe as ArchbaseRemoteApiService,
+  Ce as ArchbaseRemoteDataSource,
+  Je as ArchbaseRemoteDataSourceV2,
+  _e as ArchbaseRemoteFilterDataSource,
+  d as DataSourceEventNames,
+  ge as DefaultPage,
+  Ut as FILTER_TYPE,
+  Ge as LocalFilter,
+  yt as MigrationValidation,
+  Gt as NORMAL,
+  kt as QUICK,
+  qe as RemoteFilter,
+  vt as USAGE_EXAMPLE,
+  qt as useArchbaseBool,
+  xt as useArchbaseDataSource,
+  Ct as useArchbaseDataSourceListener,
+  be as useArchbaseDataSourceV2,
+  wt as useArchbaseDataSourceV2Editor,
+  It as useArchbaseDataSourceV2ReadOnly,
+  Ot as useArchbaseDidMount,
+  Pt as useArchbaseDidUpdate,
+  Ht as useArchbaseEventListener,
+  Bt as useArchbaseForceRerender,
+  $t as useArchbaseForceUpdate,
+  bt as useArchbaseLocalFilterDataSource,
+  Dt as useArchbaseRemoteDataSource,
+  De as useArchbaseRemoteDataSourceV2,
+  St as useArchbaseRemoteDataSourceV2Editor,
+  Et as useArchbaseRemoteDataSourceV2ReadOnly,
+  Vt as useArchbaseRemoteFilterDataSource,
+  Tt as useArchbaseRemoteServiceApi,
+  Nt as useArchbaseStore,
+  pt as useArchbaseV1V2Compatibility,
+  Lt as useArchbaseWillUnmount
+};