var __typeError = (msg) => {
  throw TypeError(msg);
};
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);

// src/dynamic-table-state-helper.ts
import { HttpContext } from "@angular/common/http";
import { signal } from "@angular/core";
import { signalState, patchState } from "@ngrx/signals";
import { firstValueFrom } from "rxjs";

// src/http-context-tokens.ts
import { HttpContextToken } from "@angular/common/http";
var SkipLoadingSpinner = new HttpContextToken(() => false);

// src/types.ts
import { z } from "zod";
var ManipulationType = /* @__PURE__ */ ((ManipulationType2) => {
  ManipulationType2["Create"] = "Create";
  ManipulationType2["Update"] = "Update";
  ManipulationType2["CreateChild"] = "Create Child";
  ManipulationType2["Delete"] = "Delete";
  ManipulationType2["View"] = "View";
  return ManipulationType2;
})(ManipulationType || {});
var dynamicQueryResponseZodSchema = z.object({
  data: z.any().array(),
  last_page: z.number(),
  last_row: z.number()
});
var PagedDataResponseZodSchema = z.object({
  payload: z.any().array(),
  totalCount: z.number()
});
function createKeyData(key, data) {
  return { key, data };
}
function isApiResponse(response) {
  return typeof response === "object" && response !== null && "data" in response && "status" in response && "success" in response;
}
function isPaginatedResponse(response) {
  return typeof response === "object" && response !== null && "data" in response && Array.isArray(response.data) && "meta" in response && typeof response.meta === "object";
}
function isSimplePagedResponse(response) {
  return typeof response === "object" && response !== null && "payload" in response && Array.isArray(response.payload) && "totalCount" in response && typeof response.totalCount === "number";
}
function isDynamicQueryResponse(response) {
  return typeof response === "object" && response !== null && "data" in response && Array.isArray(response.data) && "last_page" in response && "last_row" in response;
}

// src/dynamic-table-state-helper.ts
function initialDynamicState() {
  return {
    data: [],
    isLoading: false,
    totalRecords: 0,
    size: 15,
    page: 1,
    filter: [],
    sort: []
  };
}
var _uniqueKey, _queryParams;
var _PrimeNgDynamicTableStateHelper = class _PrimeNgDynamicTableStateHelper {
  constructor(url, httpClient, skipLoadingSpinner = true) {
    this.url = url;
    this.httpClient = httpClient;
    this.state = signalState(initialDynamicState());
    __privateAdd(this, _uniqueKey, signal("id"));
    this.uniqueKey = __privateGet(this, _uniqueKey).asReadonly();
    __privateAdd(this, _queryParams, {});
    // Public readonly signals
    this.totalRecords = this.state.totalRecords;
    this.isLoading = this.state.isLoading;
    this.data = this.state.data;
    this.urlWithOutRouteParam = url;
    this.skipLoadingSpinner = skipLoadingSpinner;
  }
  /**
   * Creates a new instance of PrimeNgDynamicTableStateHelper
   * @param options - Configuration options
   * @returns New instance of PrimeNgDynamicTableStateHelper
   */
  static create(options) {
    return new _PrimeNgDynamicTableStateHelper(
      options.url,
      options.httpClient,
      options.skipLoadingSpinner ?? true
    );
  }
  /**
   * Sets whether to skip the loading spinner
   * @param skip - Whether to skip the loading spinner
   * @returns This instance for method chaining
   */
  setSkipLoadingSpinner(skip) {
    this.skipLoadingSpinner = skip;
    return this;
  }
  /**
   * Sets the unique key field for table rows
   * @param newUniqueKey - The field name to use as unique identifier
   * @returns This instance for method chaining
   */
  setUniqueKey(newUniqueKey) {
    __privateGet(this, _uniqueKey).set(newUniqueKey);
    return this;
  }
  /**
   * Updates the API URL
   * @param newUrl - The new API URL
   * @returns This instance for method chaining
   */
  setUrl(newUrl) {
    this.url = newUrl;
    this.urlWithOutRouteParam = newUrl;
    return this;
  }
  /**
   * Appends a route parameter to the URL
   * @param newRouteParam - The route parameter to append
   * @returns This instance for method chaining
   */
  setRouteParam(newRouteParam) {
    this.url = `${this.urlWithOutRouteParam}/${newRouteParam}`;
    return this;
  }
  /**
   * Patches existing query parameters
   * @param value - Query parameters to merge
   * @returns This instance for method chaining
   */
  patchQueryParams(value) {
    __privateSet(this, _queryParams, { ...__privateGet(this, _queryParams), ...value });
    return this;
  }
  /**
   * Removes a specific query parameter
   * @param key - The key to remove
   * @returns This instance for method chaining
   */
  removeQueryParam(key) {
    delete __privateGet(this, _queryParams)[key];
    return this;
  }
  /**
   * Sets all query parameters (replaces existing)
   * @param newQueryParams - New query parameters
   * @returns This instance for method chaining
   */
  setQueryParams(newQueryParams) {
    __privateSet(this, _queryParams, newQueryParams);
    return this;
  }
  /**
   * Handles PrimeNG table lazy load events
   * @param event - The lazy load event from PrimeNG table
   */
  async onLazyLoad(event) {
    patchState(this.state, {
      size: event.rows || 15,
      page: Math.floor((event.first || 0) / (event.rows || 15)) + 1,
      filter: this.filterMapper(event.filters || {}),
      sort: Object.keys(event.multiSortMeta || {}).length > 0 ? (event.multiSortMeta || []).map((sort) => ({
        field: sort.field,
        dir: sort.order === 1 ? "asc" : "desc"
      })) : event.sortField ? [{
        field: event.sortField,
        dir: (event.sortOrder || 1) === 1 ? "asc" : "desc"
      }] : []
    });
    await this.fetchData(this.dtoBuilder());
  }
  /**
   * Clears table data and resets to first page
   * @param table - Optional PrimeNG Table reference to reset
   */
  async clearTableData(table) {
    patchState(this.state, {
      data: [],
      totalRecords: 0,
      page: 1,
      filter: [],
      sort: []
    });
    if (table) {
      table.reset();
    }
    await this.fetchData(this.dtoBuilder());
  }
  /**
   * Manually triggers data refresh with current state
   */
  async refresh() {
    await this.fetchData(this.dtoBuilder());
  }
  /**
   * Fetches data from the API
   */
  async fetchData(dto) {
    try {
      patchState(this.state, { isLoading: true });
      const params = new URLSearchParams();
      Object.entries(__privateGet(this, _queryParams)).forEach(([key, value]) => {
        params.append(key, String(value));
      });
      const urlWithParams = params.toString() ? `${this.url}?${params.toString()}` : this.url;
      const response = await firstValueFrom(
        this.httpClient.post(urlWithParams, dto, { context: new HttpContext().set(SkipLoadingSpinner, this.skipLoadingSpinner) })
      );
      const validatedResponse = dynamicQueryResponseZodSchema.parse(response);
      patchState(this.state, {
        data: validatedResponse.data,
        totalRecords: validatedResponse.last_row,
        isLoading: false
      });
    } catch (error) {
      console.error("Error fetching table data:", error);
      patchState(this.state, {
        data: [],
        totalRecords: 0,
        isLoading: false
      });
    }
  }
  /**
   * Builds the DTO for API requests
   */
  dtoBuilder() {
    return {
      size: this.state.size(),
      page: this.state.page(),
      filter: this.state.filter(),
      sort: this.state.sort()
    };
  }
  /**
   * Maps PrimeNG filters to API filter format
   */
  filterMapper(dto) {
    const filters = [];
    Object.entries(dto).forEach(([field, filterData]) => {
      if (!filterData) return;
      const processFilter = (filter) => {
        if (filter.value === null || filter.value === void 0 || filter.value === "") return;
        const mappedType = this.evaluateInput(filter.matchMode || "contains");
        if (mappedType) {
          filters.push({
            field,
            value: String(filter.value),
            type: mappedType
          });
        }
      };
      if (Array.isArray(filterData)) {
        filterData.forEach(processFilter);
      } else {
        processFilter(filterData);
      }
    });
    return filters;
  }
  /**
   * Maps PrimeNG filter match modes to API filter types
   */
  evaluateInput(input) {
    const filterMap = {
      startsWith: "starts",
      notStartsWith: "!starts",
      endsWith: "ends",
      notEndsWith: "!ends",
      contains: "like",
      notContains: "!like",
      equals: "=",
      notEquals: "!=",
      greaterThan: ">",
      lessThan: "<",
      greaterThanOrEqual: ">=",
      lessThanOrEqual: "<="
    };
    return filterMap[input] || null;
  }
};
_uniqueKey = new WeakMap();
_queryParams = new WeakMap();
var PrimeNgDynamicTableStateHelper = _PrimeNgDynamicTableStateHelper;

// src/paged-table-state-helper.ts
import { HttpContext as HttpContext2 } from "@angular/common/http";
import { signal as signal2 } from "@angular/core";
import { signalState as signalState2, patchState as patchState2 } from "@ngrx/signals";
import { firstValueFrom as firstValueFrom2 } from "rxjs";
function initialPagedState() {
  return {
    data: [],
    isLoading: false,
    totalRecords: 0,
    limit: 15,
    page: 1
  };
}
var _state, _uniqueKey2, _queryParams2;
var _PrimengPagedDataTableStateHelper = class _PrimengPagedDataTableStateHelper {
  constructor(url, httpClient, skipLoadingSpinner = true) {
    this.url = url;
    this.httpClient = httpClient;
    __privateAdd(this, _state, signalState2(initialPagedState()));
    __privateAdd(this, _uniqueKey2, signal2("id"));
    this.uniqueKey = __privateGet(this, _uniqueKey2).asReadonly();
    __privateAdd(this, _queryParams2, {});
    // Public readonly signals
    this.totalRecords = __privateGet(this, _state).totalRecords;
    this.isLoading = __privateGet(this, _state).isLoading;
    this.data = __privateGet(this, _state).data;
    this.currentPage = __privateGet(this, _state).page;
    this.currentPageSize = __privateGet(this, _state).limit;
    this.urlWithOutRouteParam = url;
    this.skipLoadingSpinner = skipLoadingSpinner;
  }
  /**
   * Creates a new instance of PrimengPagedDataTableStateHelper
   * @param option - Configuration options
   * @returns New instance of PrimengPagedDataTableStateHelper
   */
  static create(option) {
    return new _PrimengPagedDataTableStateHelper(option.url, option.httpClient, option.skipLoadingSpinner ?? true);
  }
  /**
   * Creates a new instance without initial URL (can be set later)
   * @param option - Configuration options without URL
   * @returns New instance of PrimengPagedDataTableStateHelper
   */
  static createWithBlankUrl(option) {
    return new _PrimengPagedDataTableStateHelper("", option.httpClient, option.skipLoadingSpinner ?? true);
  }
  /**
   * Sets whether to skip the loading spinner
   * @param skip - Whether to skip the loading spinner
   * @returns This instance for method chaining
   */
  setSkipLoadingSpinner(skip) {
    this.skipLoadingSpinner = skip;
    return this;
  }
  /**
   * Sets the unique key field for table rows
   * @param newUniqueKey - The field name to use as unique identifier
   * @returns This instance for method chaining
   */
  setUniqueKey(newUniqueKey) {
    __privateGet(this, _uniqueKey2).set(newUniqueKey);
    return this;
  }
  /**
   * Updates the API URL
   * @param newUrl - The new API URL
   * @returns This instance for method chaining
   */
  setUrl(newUrl) {
    this.url = newUrl;
    this.urlWithOutRouteParam = newUrl;
    return this;
  }
  /**
   * Appends a route parameter to the URL
   * @param newRouteParam - The route parameter to append
   * @returns This instance for method chaining
   */
  setRouteParam(newRouteParam) {
    this.url = `${this.urlWithOutRouteParam}/${newRouteParam}`;
    return this;
  }
  /**
   * Patches existing query parameters
   * @param value - Query parameters to merge
   * @returns This instance for method chaining
   */
  patchQueryParams(value) {
    __privateSet(this, _queryParams2, { ...__privateGet(this, _queryParams2), ...value });
    return this;
  }
  /**
   * Removes a specific query parameter
   * @param key - The key to remove
   * @returns This instance for method chaining
   */
  removeQueryParam(key) {
    delete __privateGet(this, _queryParams2)[key];
    return this;
  }
  /**
   * Removes all query parameters
   * @returns This instance for method chaining
   */
  removeAllQueryParams() {
    __privateSet(this, _queryParams2, {});
    return this;
  }
  /**
   * Sets all query parameters (replaces existing)
   * @param newQueryParams - New query parameters
   * @returns This instance for method chaining
   */
  setQueryParams(newQueryParams) {
    __privateSet(this, _queryParams2, newQueryParams);
    return this;
  }
  /**
   * Handles PrimeNG table lazy load events
   * @param event - The lazy load event from PrimeNG table
   */
  async onLazyLoad(event) {
    const newPage = Math.floor((event.first || 0) / (event.rows || 15)) + 1;
    const newLimit = event.rows || 15;
    patchState2(__privateGet(this, _state), {
      limit: newLimit,
      page: newPage
    });
    await this.fetchData(this.dtoBuilder());
  }
  /**
   * Clears table data and resets to first page
   * @param table - Optional PrimeNG Table reference to reset
   */
  async clearTableData(table) {
    patchState2(__privateGet(this, _state), {
      data: [],
      totalRecords: 0,
      page: 1
    });
    if (table) {
      table.reset();
    }
    await this.fetchData(this.dtoBuilder());
  }
  /**
   * Manually triggers data refresh with current state
   */
  async refresh() {
    await this.fetchData(this.dtoBuilder());
  }
  /**
   * Fetches data from the API
   */
  async fetchData(dto) {
    try {
      patchState2(__privateGet(this, _state), { isLoading: true });
      const params = new URLSearchParams();
      Object.entries(__privateGet(this, _queryParams2)).forEach(([key, value]) => {
        params.append(key, String(value));
      });
      Object.entries(dto).forEach(([key, value]) => {
        params.append(key, String(value));
      });
      const urlWithParams = params.toString() ? `${this.url}?${params.toString()}` : this.url;
      const response = await firstValueFrom2(
        this.httpClient.get(urlWithParams, { context: new HttpContext2().set(SkipLoadingSpinner, this.skipLoadingSpinner) })
      );
      const validatedResponse = PagedDataResponseZodSchema.parse(response);
      patchState2(__privateGet(this, _state), {
        data: validatedResponse.payload,
        totalRecords: validatedResponse.totalCount,
        isLoading: false
      });
    } catch (error) {
      console.error("Error fetching paged data:", error);
      patchState2(__privateGet(this, _state), {
        data: [],
        totalRecords: 0,
        isLoading: false
      });
    }
  }
  /**
   * Builds the DTO for API requests
   */
  dtoBuilder() {
    return {
      limit: __privateGet(this, _state).limit(),
      page: __privateGet(this, _state).page()
    };
  }
};
_state = new WeakMap();
_uniqueKey2 = new WeakMap();
_queryParams2 = new WeakMap();
var PrimengPagedDataTableStateHelper = _PrimengPagedDataTableStateHelper;

// src/table-utils.ts
function createPrimengNumberMatchModes(styleClass = "p-text-capitalize", disabled = false) {
  return [
    {
      label: "Equals",
      value: "equals",
      title: "Equals",
      styleClass,
      disabled
    },
    {
      label: "Not Equals",
      value: "notEquals",
      title: "Not Equals",
      styleClass,
      disabled
    },
    {
      label: "Greater Than",
      value: "greaterThan",
      title: "Greater Than",
      styleClass,
      disabled
    },
    {
      label: "Greater Than Or Equals",
      value: "greaterThanOrEqual",
      title: "Greater Than Or Equals",
      styleClass,
      disabled
    },
    {
      label: "Less Than",
      value: "lessThan",
      title: "Less Than",
      styleClass,
      disabled
    },
    {
      label: "Less Than Or Equals",
      value: "lessThanOrEqual",
      title: "Less Than Or Equals",
      styleClass,
      disabled
    }
  ];
}
function createPrimengStringMatchModes(styleClass = "p-text-capitalize", disabled = false) {
  return [
    {
      label: "Contains",
      value: "contains",
      title: "Contains",
      styleClass,
      disabled
    },
    {
      label: "Not Contains",
      value: "notContains",
      title: "Not Contains",
      styleClass,
      disabled
    },
    {
      label: "Starts With",
      value: "startsWith",
      title: "Starts With",
      styleClass,
      disabled
    },
    {
      label: "Not Starts With",
      value: "notStartsWith",
      title: "Not Starts With",
      styleClass,
      disabled
    },
    {
      label: "Ends With",
      value: "endsWith",
      title: "Ends With",
      styleClass,
      disabled
    },
    {
      label: "Not Ends With",
      value: "notEndsWith",
      title: "Not Ends With",
      styleClass,
      disabled
    }
  ];
}
function createTextColumn(field, label, options = {}) {
  const header = {
    identifier: {
      label,
      field,
      hasSort: options.hasSort ?? false,
      styleClass: options.styleClass
    }
  };
  if (options.hasFilter ?? false) {
    header.filter = {
      type: "text",
      placeholder: options.placeholder ?? `Search by ${label.toLowerCase()}`,
      matchModeOptions: options.matchModeOptions ?? createPrimengStringMatchModes(),
      defaultMatchMode: options.defaultMatchMode ?? "contains",
      ariaLabel: `Filter by ${label}`,
      styleClass: options.filterStyleClass
    };
  }
  return header;
}
function createNumericColumn(field, label, options = {}) {
  const header = {
    identifier: {
      label,
      field,
      hasSort: options.hasSort ?? false,
      styleClass: options.styleClass
    }
  };
  if (options.hasFilter ?? false) {
    header.filter = {
      type: "numeric",
      placeholder: options.placeholder ?? `Filter by ${label.toLowerCase()}`,
      matchModeOptions: options.matchModeOptions ?? createPrimengNumberMatchModes(),
      defaultMatchMode: options.defaultMatchMode ?? "equals",
      ariaLabel: `Filter by ${label}`,
      styleClass: options.filterStyleClass
    };
  }
  return header;
}
function createBooleanColumn(field, label, options = {}) {
  const header = {
    identifier: {
      label,
      field,
      hasSort: options.hasSort ?? false,
      isBoolean: true,
      styleClass: options.styleClass
    }
  };
  if (options.hasFilter ?? false) {
    header.filter = {
      type: "boolean",
      defaultMatchMode: "equals",
      ariaLabel: `Filter by ${label}`,
      styleClass: options.filterStyleClass
    };
  }
  return header;
}
function createDateColumn(field, label, options = {}) {
  const header = {
    identifier: {
      label,
      field,
      hasSort: options.hasSort ?? false,
      styleClass: options.styleClass
    }
  };
  if (options.hasFilter ?? false) {
    header.filter = {
      type: "date",
      placeholder: options.placeholder ?? `Select ${label.toLowerCase()}`,
      defaultMatchMode: "equals",
      ariaLabel: `Filter by ${label}`,
      styleClass: options.filterStyleClass
    };
  }
  return header;
}
function createDropdownColumn(field, label, dropdownOptions, options = {}) {
  const header = {
    identifier: {
      label,
      field,
      hasSort: options.hasSort ?? false,
      styleClass: options.styleClass
    }
  };
  if (options.hasFilter ?? false) {
    header.filter = {
      type: "dropdown",
      placeholder: options.placeholder ?? `Select ${label.toLowerCase()}`,
      matchModeOptions: dropdownOptions,
      defaultMatchMode: "equals",
      ariaLabel: `Filter by ${label}`,
      styleClass: options.filterStyleClass
    };
  }
  return header;
}
function createMultiselectColumn(field, label, multiselectOptions, options = {}) {
  const header = {
    identifier: {
      label,
      field,
      hasSort: options.hasSort ?? false,
      styleClass: options.styleClass
    }
  };
  if (options.hasFilter ?? false) {
    header.filter = {
      type: "multiselect",
      placeholder: options.placeholder ?? `Select ${label.toLowerCase()}`,
      matchModeOptions: multiselectOptions,
      defaultMatchMode: "equals",
      ariaLabel: `Filter by ${label}`,
      styleClass: options.filterStyleClass
    };
  }
  return header;
}
function createSimpleColumn(field, label, options = {}) {
  return {
    identifier: {
      label,
      field,
      hasSort: options.hasSort ?? false,
      styleClass: options.styleClass
    }
  };
}
function mergeTableHeaders(...headers) {
  return headers;
}
function createBooleanSelectItems(trueLabel = "Yes", falseLabel = "No") {
  return [
    { label: trueLabel, value: true },
    { label: falseLabel, value: false }
  ];
}
function createStatusSelectItems(statusOptions) {
  return Object.entries(statusOptions).map(([value, label]) => ({
    label,
    value: isNaN(Number(value)) ? value : Number(value)
  }));
}

// src/utils.ts
function cleanNullishFromObject(o) {
  return Object.fromEntries(Object.entries(o).filter(([, v]) => v != null));
}

// src/memoized-data-storage.ts
import { signal as signal3 } from "@angular/core";
import { HttpContext as HttpContext3 } from "@angular/common/http";
import { firstValueFrom as firstValueFrom3 } from "rxjs";
var _singleData, _multipleData, _isLoading, _isMemoizationDisabledOnNextRead;
var MemoizedDataStorage = class {
  /**
   * Creates a new instance of MemoizedDataStorage
   * @param httpClient Angular HttpClient instance for making HTTP requests
   * @param skipLoadingSpinner Whether to skip the loading spinner for HTTP requests
   */
  constructor(httpClient, skipLoadingSpinner = true) {
    this.httpClient = httpClient;
    this.skipLoadingSpinner = true;
    __privateAdd(this, _singleData, signal3(null));
    __privateAdd(this, _multipleData, signal3([]));
    __privateAdd(this, _isLoading, signal3(false));
    // Public readonly signals for external consumption
    /**
     * Read-only signal containing single data object or null
     */
    this.singleData = __privateGet(this, _singleData).asReadonly();
    /**
     * Read-only signal containing array of data objects
     */
    this.multipleData = __privateGet(this, _multipleData).asReadonly();
    /**
     * Read-only signal indicating whether a request is currently loading
     */
    this.isLoading = __privateGet(this, _isLoading).asReadonly();
    // Private flag to control memoization behavior
    __privateAdd(this, _isMemoizationDisabledOnNextRead, false);
    this.skipLoadingSpinner = skipLoadingSpinner;
  }
  /**
   * Sets whether to skip the loading spinner for HTTP requests
   * @param skip Whether to skip the loading spinner
   * @returns This instance for method chaining
   */
  setSkipLoadingSpinner(skip) {
    this.skipLoadingSpinner = skip;
    return this;
  }
  /**
   * Disables memoization for the next read operation and clears cached data
   * This forces the next loadSingleData or loadMultipleData call to fetch fresh data
   * 
   * @example
   * ```typescript
   * const storage = new MemoizedDataStorage<User>(httpClient);
   * await storage.loadSingleData('/api/user/1'); // Fetches data
   * await storage.loadSingleData('/api/user/1'); // Returns cached data
   * 
   * storage.disableMemoizationOnNextRead();
   * await storage.loadSingleData('/api/user/1'); // Fetches fresh data
   * ```
   */
  disableMemoizationOnNextRead() {
    __privateSet(this, _isMemoizationDisabledOnNextRead, true);
    __privateGet(this, _singleData).set(null);
    __privateGet(this, _multipleData).set([]);
  }
  /**
   * Loads a single data object from the specified URL with optional query parameters
   * Uses memoization to avoid redundant requests unless explicitly disabled
   * 
   * @param url The URL to fetch data from
   * @param queryParams Optional query parameters to include in the request
   * @returns Promise that resolves when the data is loaded
   * @throws Error if the HTTP request fails
   * 
   * @example
   * ```typescript
   * const storage = new MemoizedDataStorage<User>(httpClient);
   * await storage.loadSingleData('/api/user/1', { include: 'profile' });
   * const user = storage.singleData(); // User data or null
   * ```
   */
  async loadSingleData(url, queryParams = {}) {
    if (!__privateGet(this, _isMemoizationDisabledOnNextRead) && __privateGet(this, _singleData).call(this) !== null) {
      return;
    }
    try {
      __privateGet(this, _isLoading).set(true);
      const data = await firstValueFrom3(
        this.httpClient.get(url, {
          params: queryParams,
          context: new HttpContext3().set(SkipLoadingSpinner, this.skipLoadingSpinner)
        })
      );
      __privateGet(this, _singleData).set(data);
    } catch (error) {
      __privateGet(this, _singleData).set(null);
      throw error;
    } finally {
      __privateGet(this, _isLoading).set(false);
      __privateSet(this, _isMemoizationDisabledOnNextRead, false);
    }
  }
  /**
   * Loads multiple data objects from the specified URL with optional query parameters
   * Uses memoization to avoid redundant requests unless explicitly disabled
   * 
   * @param url The URL to fetch data from
   * @param queryParams Optional query parameters to include in the request
   * @returns Promise that resolves when the data is loaded
   * @throws Error if the HTTP request fails
   * 
   * @example
   * ```typescript
   * const storage = new MemoizedDataStorage<User>(httpClient);
   * await storage.loadMultipleData('/api/users', { page: 1, limit: 10 });
   * const users = storage.multipleData(); // Array of User data
   * ```
   */
  async loadMultipleData(url, queryParams = {}) {
    if (!__privateGet(this, _isMemoizationDisabledOnNextRead) && __privateGet(this, _multipleData).call(this).length !== 0) {
      return;
    }
    try {
      __privateGet(this, _isLoading).set(true);
      const context = new HttpContext3();
      if (this.skipLoadingSpinner) {
        context.set(SkipLoadingSpinner, true);
      }
      const data = await firstValueFrom3(
        this.httpClient.get(url, {
          params: queryParams,
          context
        })
      );
      __privateGet(this, _multipleData).set(Array.isArray(data) ? data : []);
    } catch (error) {
      __privateGet(this, _multipleData).set([]);
      throw error;
    } finally {
      __privateGet(this, _isLoading).set(false);
      __privateSet(this, _isMemoizationDisabledOnNextRead, false);
    }
  }
  /**
   * Clears all cached data and resets the storage to initial state
   * 
   * @example
   * ```typescript
   * const storage = new MemoizedDataStorage<User>(httpClient);
   * await storage.loadSingleData('/api/user/1');
   * storage.clear(); // Clears cached data
   * console.log(storage.singleData()); // null
   * console.log(storage.multipleData()); // []
   * ```
   */
  clear() {
    __privateGet(this, _singleData).set(null);
    __privateGet(this, _multipleData).set([]);
    __privateSet(this, _isMemoizationDisabledOnNextRead, false);
  }
  /**
   * Checks if single data is currently cached
   * @returns true if single data is cached, false otherwise
   */
  hasSingleData() {
    return __privateGet(this, _singleData).call(this) !== null;
  }
  /**
   * Checks if multiple data is currently cached
   * @returns true if multiple data is cached (non-empty array), false otherwise
   */
  hasMultipleData() {
    return __privateGet(this, _multipleData).call(this).length > 0;
  }
};
_singleData = new WeakMap();
_multipleData = new WeakMap();
_isLoading = new WeakMap();
_isMemoizationDisabledOnNextRead = new WeakMap();

// src/component-state.ts
import { computed, signal as signal4 } from "@angular/core";
var ComponentState = class {
  constructor() {
    this.isAjaxDataIncoming = signal4(false);
    this.enableCheckBoxSelection = signal4(false);
    this.isSelectableRowEnabled = signal4(false);
    this.isAjaxRequestOutgoing = signal4(false);
    this.hasMultipleSelection = signal4(false);
    this.isCreateOrUpdateDialogOpen = signal4(false);
    this.isUpdateDialogOpen = signal4(false);
    this.isCreateDialogOpen = signal4(false);
    this.manipulationType = signal4("Create" /* Create */);
    this.componentTitle = signal4("");
    /**
     * Updates the component title
     * @param componentTitle - The new title for the component
     * @returns This instance for method chaining
     */
    this.updateComponentTitle = (componentTitle) => {
      this.componentTitle.set(componentTitle);
      return this;
    };
    /**
     * Updates the multiple selection status
     * @param newStatus - Whether multiple selection is enabled
     * @returns This instance for method chaining
     */
    this.updateMultipleSelectionStatus = (newStatus) => {
      this.hasMultipleSelection.set(newStatus);
      return this;
    };
    /**
     * Updates the checkbox selection status
     * @param newStatus - Whether checkbox selection is enabled
     * @returns This instance for method chaining
     */
    this.updateCheckBoxSelectionStatus = (newStatus) => {
      this.enableCheckBoxSelection.set(newStatus);
      return this;
    };
    /**
     * Updates the selectable row status
     * @param newStatus - Whether row selection is enabled
     * @returns This instance for method chaining
     */
    this.updateSelectableRowStatus = (newStatus) => {
      this.isSelectableRowEnabled.set(newStatus);
      return this;
    };
    /**
     * Updates the manipulation type (Create, Update, Delete, View)
     * @param type - The manipulation type
     * @returns This instance for method chaining
     */
    this.updateManipulationType = (type) => {
      this.manipulationType.set(type);
      return this;
    };
    /**
     * Sets the incoming Ajax data status
     * @param status - Whether Ajax data is incoming
     * @returns This instance for method chaining
     */
    this.setAjaxDataIncoming = (status) => {
      this.isAjaxDataIncoming.set(status);
      return this;
    };
    /**
     * Sets the outgoing Ajax request status
     * @param status - Whether Ajax request is outgoing
     * @returns This instance for method chaining
     */
    this.setAjaxRequestOutgoing = (status) => {
      this.isAjaxRequestOutgoing.set(status);
      return this;
    };
    /**
     * Sets the create or update dialog open status
     * @param status - Whether the dialog is open
     * @returns This instance for method chaining
     */
    this.setCreateOrUpdateDialogOpen = (status) => {
      this.isCreateOrUpdateDialogOpen.set(status);
      return this;
    };
    /**
     * Sets the update dialog open status
     * @param status - Whether the update dialog is open
     * @returns This instance for method chaining
     */
    this.setUpdateDialogOpen = (status) => {
      this.isUpdateDialogOpen.set(status);
      return this;
    };
    /**
     * Sets the create dialog open status
     * @param status - Whether the create dialog is open
     * @returns This instance for method chaining
     */
    this.setCreateDialogOpen = (status) => {
      this.isCreateDialogOpen.set(status);
      return this;
    };
    /**
     * Computed signal that combines component title with manipulation type
     */
    this.componentTitleWithManipulationType = computed(() => {
      return this.manipulationType() + " " + this.componentTitle();
    });
    /**
     * Computed signal that indicates if component is in update state
     */
    this.isOnUpdateState = computed(() => {
      return this.manipulationType() === "Update" /* Update */;
    });
    /**
     * Computed signal that indicates if component is in create state
     */
    this.isOnCreateState = computed(() => {
      return this.manipulationType() === "Create" /* Create */;
    });
    /**
     * Computed signal that indicates if component is in delete state
     */
    this.isOnDeleteState = computed(() => {
      return this.manipulationType() === "Delete" /* Delete */;
    });
    /**
     * Computed signal that indicates if component is in view state
     */
    this.isOnViewState = computed(() => {
      return this.manipulationType() === "View" /* View */;
    });
    /**
     * Computed signal that indicates if any Ajax operation is currently running
     */
    this.isAnyAjaxOperationRunning = computed(() => {
      return this.isAjaxDataIncoming() || this.isAjaxRequestOutgoing();
    });
    /**
     * Computed signal that indicates if any dialog is open
     */
    this.isAnyDialogOpen = computed(() => {
      return this.isCreateOrUpdateDialogOpen() || this.isUpdateDialogOpen() || this.isCreateDialogOpen();
    });
    /**
     * Resets all state to default values
     * @returns This instance for method chaining
     */
    this.reset = () => {
      this.isAjaxDataIncoming.set(false);
      this.enableCheckBoxSelection.set(false);
      this.isSelectableRowEnabled.set(false);
      this.isAjaxRequestOutgoing.set(false);
      this.hasMultipleSelection.set(false);
      this.isCreateOrUpdateDialogOpen.set(false);
      this.isUpdateDialogOpen.set(false);
      this.isCreateDialogOpen.set(false);
      this.manipulationType.set("Create" /* Create */);
      this.componentTitle.set("");
      return this;
    };
  }
};

// src/component-data-storage.ts
import { signal as signal5 } from "@angular/core";
var ComponentDataStorage = class {
  constructor() {
    this.singleData = signal5(null);
    this.multipleData = signal5([]);
  }
  /**
   * Patches multiple data by appending new data to the existing array
   * @param newData - Array of new data to append
   * @returns This instance for method chaining
   * 
   * @example
   * ```typescript
   * const storage = new ComponentDataStorage<User>();
   * storage.updateMultipleData([{ id: 1, name: 'John' }]);
   * storage.patchMultipleData([{ id: 2, name: 'Jane' }]);
   * // Result: [{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]
   * ```
   */
  patchMultipleData(newData) {
    this.multipleData.update((prevData) => {
      return [...prevData, ...newData];
    });
    return this;
  }
  /**
   * Patches single data by merging new properties with existing data
   * If no existing data, creates new object with provided data
   * @param newData - Partial data to merge with existing single data
   * @returns This instance for method chaining
   * 
   * @example
   * ```typescript
   * const storage = new ComponentDataStorage<User>();
   * storage.updateSingleData({ id: 1, name: 'John', email: 'john@example.com' });
   * storage.patchSingleData({ email: 'john.doe@example.com' });
   * // Result: { id: 1, name: 'John', email: 'john.doe@example.com' }
   * ```
   */
  patchSingleData(newData) {
    this.singleData.update((prev) => prev ? { ...prev, ...newData } : { ...newData });
    return this;
  }
  /**
   * Replaces the entire multiple data array
   * @param newData - New array of data to replace existing data
   * @returns This instance for method chaining
   */
  updateMultipleData(newData) {
    this.multipleData.set(newData);
    return this;
  }
  /**
   * Replaces the single data object
   * @param newData - New data object or null to replace existing data
   * @returns This instance for method chaining
   */
  updateSingleData(newData) {
    this.singleData.set(newData);
    return this;
  }
  /**
   * Adds a single item to the multiple data array
   * @param item - Single item to add to the array
   * @returns This instance for method chaining
   */
  addToMultipleData(item) {
    this.multipleData.update((prevData) => [...prevData, item]);
    return this;
  }
  /**
   * Removes an item from the multiple data array based on a predicate function
   * @param predicate - Function that returns true for items to remove
   * @returns This instance for method chaining
   * 
   * @example
   * ```typescript
   * storage.removeFromMultipleData(user => user.id === 1);
   * ```
   */
  removeFromMultipleData(predicate) {
    this.multipleData.update((prevData) => prevData.filter((item) => !predicate(item)));
    return this;
  }
  /**
   * Updates an item in the multiple data array based on a predicate function
   * @param predicate - Function that returns true for items to update
   * @param updateFn - Function that returns the updated item
   * @returns This instance for method chaining
   * 
   * @example
   * ```typescript
   * storage.updateItemInMultipleData(
   *   user => user.id === 1,
   *   user => ({ ...user, name: 'Updated Name' })
   * );
   * ```
   */
  updateItemInMultipleData(predicate, updateFn) {
    this.multipleData.update(
      (prevData) => prevData.map((item) => predicate(item) ? updateFn(item) : item)
    );
    return this;
  }
  /**
   * Clears all data (both single and multiple)
   * @returns This instance for method chaining
   */
  clearAll() {
    this.singleData.set(null);
    this.multipleData.set([]);
    return this;
  }
  /**
   * Clears only the single data
   * @returns This instance for method chaining
   */
  clearSingleData() {
    this.singleData.set(null);
    return this;
  }
  /**
   * Clears only the multiple data
   * @returns This instance for method chaining
   */
  clearMultipleData() {
    this.multipleData.set([]);
    return this;
  }
  /**
   * Checks if single data exists (is not null)
   * @returns true if single data exists, false otherwise
   */
  hasSingleData() {
    return this.singleData() !== null;
  }
  /**
   * Checks if multiple data has items
   * @returns true if multiple data array has items, false if empty
   */
  hasMultipleData() {
    return this.multipleData().length > 0;
  }
  /**
   * Gets the count of items in multiple data
   * @returns Number of items in the multiple data array
   */
  getMultipleDataCount() {
    return this.multipleData().length;
  }
  /**
   * Finds an item in the multiple data array
   * @param predicate - Function that returns true for the item to find
   * @returns The found item or undefined
   */
  findInMultipleData(predicate) {
    return this.multipleData().find(predicate);
  }
  /**
   * Checks if an item exists in the multiple data array
   * @param predicate - Function that returns true for the item to check
   * @returns true if item exists, false otherwise
   */
  existsInMultipleData(predicate) {
    return this.multipleData().some(predicate);
  }
};

// src/ng-select-helper.ts
import { HttpContext as HttpContext4 } from "@angular/common/http";
import { signal as signal6 } from "@angular/core";
import {
  catchError,
  debounceTime,
  finalize,
  first,
  mergeMap,
  of,
  Subject,
  switchMap
} from "rxjs";
import { z as z2 } from "zod";
var NgSelectPagedDataResponse = class {
  constructor(payload, totalCount) {
    this.payload = payload;
    this.totalCount = totalCount;
  }
};
var NgSelectPagedDataResponseZodSchema = z2.object({
  payload: z2.any().array(),
  totalCount: z2.number()
});
var defaultResetOpts = {
  resetQueryParams: false,
  resetBody: false,
  resetCache: false
};
var _cache, _originalAjaxUrl, _queryParams3, _body, _initDone, _searchText, _limit, _page, _debounceTimeInSec, _totalCount, _isLastApiCallSuccessful, _limitReached, _loadMoreDataSubject, _ajaxErrorSubject, _loadedData, _isLoading2;
var _NgSelectHelper = class _NgSelectHelper {
  constructor(ajaxUrl, httpClient, destroyRef, usePostRequest = false, limit = 50, useCache = true, skipLoadingSpinner = true) {
    this.ajaxUrl = ajaxUrl;
    this.httpClient = httpClient;
    this.destroyRef = destroyRef;
    this.usePostRequest = usePostRequest;
    this.useCache = useCache;
    this.skipLoadingSpinner = skipLoadingSpinner;
    __privateAdd(this, _cache, /* @__PURE__ */ new Map());
    __privateAdd(this, _originalAjaxUrl);
    __privateAdd(this, _queryParams3, {});
    __privateAdd(this, _body, {});
    __privateAdd(this, _initDone, false);
    __privateAdd(this, _searchText, "");
    __privateAdd(this, _limit);
    __privateAdd(this, _page, 1);
    __privateAdd(this, _debounceTimeInSec, 1);
    __privateAdd(this, _totalCount, -1);
    __privateAdd(this, _isLastApiCallSuccessful, true);
    __privateAdd(this, _limitReached, false);
    __privateAdd(this, _loadMoreDataSubject, new Subject());
    this.inputSubject = new Subject();
    __privateAdd(this, _ajaxErrorSubject, new Subject());
    this.ajaxError$ = __privateGet(this, _ajaxErrorSubject).asObservable();
    __privateAdd(this, _loadedData, signal6(
      new NgSelectPagedDataResponse([], 0)
    ));
    this.loadedData = __privateGet(this, _loadedData).asReadonly();
    __privateAdd(this, _isLoading2, signal6(false));
    this.isLoading = __privateGet(this, _isLoading2).asReadonly();
    this.runningApiReq = null;
    __privateSet(this, _originalAjaxUrl, ajaxUrl);
    __privateSet(this, _limit, limit > 0 ? limit : 50);
    this.destroyRef.onDestroy(() => {
      __privateGet(this, _ajaxErrorSubject).complete();
      this.inputSubject.complete();
      __privateGet(this, _loadMoreDataSubject).complete();
      __privateGet(this, _cache).clear();
      if (this.runningApiReq && !this.runningApiReq.closed) {
        this.runningApiReq.unsubscribe();
      }
    });
  }
  /**
   * Creates a new instance of NgSelectHelper
   * @param options Configuration options
   * @returns New NgSelectHelper instance
   */
  static create({
    ajaxUrl,
    httpClient,
    destroyRef,
    usePostRequest,
    limit = 50,
    useCache = true,
    skipLoadingSpinner = true
  }) {
    return new _NgSelectHelper(
      ajaxUrl,
      httpClient,
      destroyRef,
      usePostRequest,
      limit,
      useCache,
      skipLoadingSpinner
    );
  }
  /**
   * Sets whether to skip the loading spinner for HTTP requests
   * @param skip Whether to skip the loading spinner
   * @returns This instance for method chaining
   */
  setSkipLoadingSpinner(skip) {
    this.skipLoadingSpinner = skip;
    return this;
  }
  /**
   * Sets the debounce time for search input in seconds
   * @param debounceTimeInSecond Debounce time in seconds
   * @returns This instance for method chaining
   */
  setDebounceTimeInSecond(debounceTimeInSecond) {
    __privateSet(this, _debounceTimeInSec, debounceTimeInSecond > 0 ? debounceTimeInSecond : 1);
    return this;
  }
  /**
   * Patches the request body (only works with POST requests)
   * @param value Body data to merge
   * @returns This instance for method chaining
   */
  patchBody(value) {
    if (this.usePostRequest) {
      this.resetAll();
      __privateSet(this, _body, Object.assign(__privateGet(this, _body), value));
    }
    return this;
  }
  /**
   * Sets the request body (only works with POST requests)
   * @param newBody New body data
   * @returns This instance for method chaining
   */
  setBody(newBody) {
    if (this.usePostRequest) {
      this.resetAll();
      __privateSet(this, _body, newBody);
    }
    return this;
  }
  /**
   * Clears the internal cache
   * @returns This instance for method chaining
   */
  clearCache() {
    __privateGet(this, _cache).clear();
    return this;
  }
  /**
   * Sets route parameters for the URL
   * @param newRouteParam Route parameter to append
   * @returns This instance for method chaining
   */
  setRouteParam(newRouteParam) {
    const baseUrl = __privateGet(this, _originalAjaxUrl).endsWith("/") ? __privateGet(this, _originalAjaxUrl).slice(0, -1) : __privateGet(this, _originalAjaxUrl);
    let routeParam = newRouteParam.startsWith("/") ? newRouteParam.slice(1) : newRouteParam;
    this.ajaxUrl = `${baseUrl}/${routeParam}`;
    return this;
  }
  /**
   * Patches query parameters
   * @param value Query parameters to merge
   * @returns This instance for method chaining
   */
  patchQueryParams(value) {
    this.resetAll();
    __privateSet(this, _queryParams3, Object.assign(__privateGet(this, _queryParams3), value));
    return this;
  }
  /**
   * Removes a query parameter
   * @param key Query parameter key to remove
   * @returns This instance for method chaining
   */
  removeQueryParam(key) {
    this.resetAll();
    delete __privateGet(this, _queryParams3)[key];
    return this;
  }
  /**
   * Sets query parameters
   * @param newQueryParams New query parameters
   * @returns This instance for method chaining
   */
  setQueryParams(newQueryParams) {
    this.resetAll();
    __privateSet(this, _queryParams3, newQueryParams);
    return this;
  }
  /**
   * Handler for ng-select blur event
   */
  onBlur() {
    this.resetAll();
  }
  /**
   * Handler for ng-select close event
   */
  onClose() {
    this.resetSearchText();
    if (this.runningApiReq && !this.runningApiReq.closed) {
      this.runningApiReq.unsubscribe();
      this.runningApiReq = null;
    }
  }
  /**
   * Handler for ng-select clear event
   */
  async onClear() {
    this.resetAll();
  }
  /**
   * Handler for ng-select open event
   */
  onOpen() {
    __privateGet(this, _loadMoreDataSubject).next();
  }
  /**
   * Handler for ng-select scroll to end event
   */
  onScrollToEnd() {
    if (__privateGet(this, _isLoading2).call(this)) {
      return;
    }
    this.runProbablePageCounterUpdate();
    __privateGet(this, _loadMoreDataSubject).next();
  }
  /**
   * Gets whether the last API call was successful
   */
  get isLastApiCallSuccessful() {
    return __privateGet(this, _isLastApiCallSuccessful);
  }
  /**
   * Gets whether the limit has been reached
   */
  get limitReached() {
    return __privateGet(this, _limitReached);
  }
  /**
   * Gets current query parameters
   */
  get queryParams() {
    return __privateGet(this, _queryParams3);
  }
  /**
   * Gets current request body
   */
  get body() {
    return __privateGet(this, _body);
  }
  /**
   * Gets current page number
   */
  get page() {
    return __privateGet(this, _page);
  }
  /**
   * Gets total count of available items
   */
  get totalCount() {
    return __privateGet(this, _totalCount);
  }
  /**
   * Gets whether initialization is complete
   */
  get isInitDone() {
    return __privateGet(this, _initDone);
  }
  /**
   * Initializes the NgSelectHelper with event handlers
   * Should be called in ngOnInit or similar lifecycle method
   */
  init() {
    if (__privateGet(this, _initDone)) {
      return;
    }
    __privateSet(this, _initDone, true);
    this.inputSubject.pipe(
      debounceTime(__privateGet(this, _debounceTimeInSec) * 500),
      switchMap((term) => {
        this.resetAll();
        __privateSet(this, _searchText, term);
        return this.loadDataFromApi(this.page, __privateGet(this, _limit), term).pipe(
          catchError(() => of(null))
        );
      })
    ).subscribe({
      next: (res) => {
        if (res) {
          this.updateStateOnSuccessfulInitialApiCall(res);
        } else {
          this.updateStateOnFailedApiCall();
        }
      }
    });
    __privateGet(this, _loadMoreDataSubject).pipe(
      switchMap(() => {
        if (__privateGet(this, _isLoading2).call(this)) {
          return of(null);
        }
        this.runLimitReachedCheck();
        if (this.limitReached) {
          return of(null);
        }
        return this.loadDataFromApi(
          this.page,
          __privateGet(this, _limit),
          __privateGet(this, _searchText)
        ).pipe(catchError(() => of(null)));
      })
    ).subscribe({
      next: (res) => {
        if (res) {
          this.updateStateOnSuccessfulSubsequentApiCall(res);
        } else {
          this.updateStateOnFailedApiCall();
        }
      }
    });
  }
  /**
   * Loads data from the API
   * @param page Page number
   * @param limit Items per page
   * @param searchText Search term
   * @returns Observable of paged data response
   */
  loadDataFromApi(page, limit, searchText) {
    const queryParams = { page, limit };
    if (searchText) {
      queryParams["searchText"] = searchText;
    }
    const key = {
      ajaxUrl: this.ajaxUrl,
      page,
      limit,
      searchText: searchText ?? "",
      queryParams: { ...queryParams, ...__privateGet(this, _queryParams3) },
      body: __privateGet(this, _body)
    };
    let strKey = null;
    if (this.useCache) {
      strKey = JSON.stringify(key);
      const cacheData = __privateGet(this, _cache).get(strKey);
      if (cacheData !== void 0) {
        return of(cacheData);
      }
    }
    __privateGet(this, _isLoading2).set(true);
    let req;
    if (this.usePostRequest) {
      req = this.httpClient.post(
        key.ajaxUrl,
        key.body,
        {
          params: key.queryParams,
          context: new HttpContext4().set(SkipLoadingSpinner, this.skipLoadingSpinner)
        }
      );
    } else {
      req = this.httpClient.get(key.ajaxUrl, {
        params: key.queryParams,
        context: new HttpContext4().set(SkipLoadingSpinner, this.skipLoadingSpinner)
      });
    }
    return req.pipe(
      first(),
      mergeMap((val) => {
        const result = NgSelectPagedDataResponseZodSchema.safeParse(val);
        if (!result.success) {
          throw new Error("Invalid response body for ng-select");
        }
        if (this.useCache && strKey && val) {
          __privateGet(this, _cache).set(strKey, val);
        }
        return of(val);
      }),
      catchError((error) => {
        __privateGet(this, _ajaxErrorSubject).next(error);
        return of(null);
      }),
      finalize(() => __privateGet(this, _isLoading2).set(false))
    );
  }
  /**
   * Updates page counter if conditions are met
   */
  runProbablePageCounterUpdate() {
    if (this.isLastApiCallSuccessful && !this.limitReached) {
      __privateSet(this, _page, __privateGet(this, _page) + 1);
    }
  }
  /**
   * Checks if the limit has been reached
   */
  runLimitReachedCheck() {
    if (this.totalCount != -1) {
      __privateSet(this, _limitReached, __privateGet(this, _loadedData).call(this).payload.length >= this.totalCount);
    }
  }
  /**
   * Updates state after successful initial API call
   * @param data Response data
   */
  updateStateOnSuccessfulInitialApiCall(data) {
    __privateGet(this, _loadedData).set(new NgSelectPagedDataResponse(data.payload, data.totalCount));
    __privateSet(this, _totalCount, data.totalCount);
    __privateSet(this, _isLastApiCallSuccessful, true);
  }
  /**
   * Updates state after successful subsequent API call
   * @param data Response data
   */
  updateStateOnSuccessfulSubsequentApiCall(data) {
    __privateGet(this, _loadedData).update((val) => {
      return new NgSelectPagedDataResponse(
        [...val.payload, ...data.payload],
        data.totalCount
      );
    });
    __privateSet(this, _totalCount, data.totalCount);
    __privateSet(this, _isLastApiCallSuccessful, true);
  }
  /**
   * Updates state after failed API call
   */
  updateStateOnFailedApiCall() {
    __privateSet(this, _isLastApiCallSuccessful, false);
  }
  /**
   * Resets all state to initial values
   * @param opts Reset options
   */
  resetAll(opts = defaultResetOpts) {
    if (this.runningApiReq && !this.runningApiReq.closed) {
      this.runningApiReq.unsubscribe();
      this.runningApiReq = null;
    }
    __privateSet(this, _isLastApiCallSuccessful, true);
    __privateSet(this, _page, 1);
    __privateSet(this, _totalCount, -1);
    __privateSet(this, _limitReached, false);
    __privateSet(this, _searchText, "");
    if (opts.resetCache) {
      __privateGet(this, _cache).clear();
    }
    __privateGet(this, _loadedData).set(new NgSelectPagedDataResponse([], 0));
    __privateGet(this, _isLoading2).set(false);
    if (opts.resetQueryParams) {
      __privateSet(this, _queryParams3, {});
    }
    if (opts.resetBody) {
      __privateSet(this, _body, {});
    }
  }
  /**
   * Resets search text
   */
  resetSearchText() {
    __privateSet(this, _searchText, "");
  }
};
_cache = new WeakMap();
_originalAjaxUrl = new WeakMap();
_queryParams3 = new WeakMap();
_body = new WeakMap();
_initDone = new WeakMap();
_searchText = new WeakMap();
_limit = new WeakMap();
_page = new WeakMap();
_debounceTimeInSec = new WeakMap();
_totalCount = new WeakMap();
_isLastApiCallSuccessful = new WeakMap();
_limitReached = new WeakMap();
_loadMoreDataSubject = new WeakMap();
_ajaxErrorSubject = new WeakMap();
_loadedData = new WeakMap();
_isLoading2 = new WeakMap();
var NgSelectHelper = _NgSelectHelper;

// src/ng-select-utils.ts
import { takeUntilDestroyed } from "@angular/core/rxjs-interop";
function initNgSelect(helpers$, destroyRef, onAjaxError) {
  helpers$.pipe(takeUntilDestroyed(destroyRef)).subscribe({
    next: (helpers) => {
      helpers.filter((elem) => elem instanceof NgSelectHelper && !elem.isInitDone).forEach((elem) => {
        elem.init();
        elem.ajaxError$.pipe(takeUntilDestroyed(destroyRef)).subscribe(onAjaxError);
      });
    }
  });
}
export {
  ComponentDataStorage,
  ComponentState,
  ManipulationType,
  MemoizedDataStorage,
  NgSelectHelper,
  NgSelectPagedDataResponse,
  NgSelectPagedDataResponseZodSchema,
  PagedDataResponseZodSchema,
  PrimeNgDynamicTableStateHelper,
  PrimengPagedDataTableStateHelper,
  SkipLoadingSpinner,
  cleanNullishFromObject,
  createBooleanColumn,
  createBooleanSelectItems,
  createDateColumn,
  createDropdownColumn,
  createKeyData,
  createMultiselectColumn,
  createNumericColumn,
  createPrimengNumberMatchModes,
  createPrimengStringMatchModes,
  createSimpleColumn,
  createStatusSelectItems,
  createTextColumn,
  dynamicQueryResponseZodSchema,
  initNgSelect,
  isApiResponse,
  isDynamicQueryResponse,
  isPaginatedResponse,
  isSimplePagedResponse,
  mergeTableHeaders
};
//# sourceMappingURL=index.mjs.map