@tanstack/angular-db/dist/cjs/index.cjs

Angular integration for @tanstack/db

"use strict";
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const core = require("@angular/core");
const db = require("@tanstack/db");
function injectLiveQuery(opts) {
  core.assertInInjectionContext(injectLiveQuery);
  const destroyRef = core.inject(core.DestroyRef);
  const collection = core.computed(() => {
    const isExistingCollection = opts && typeof opts === `object` && typeof opts.subscribeChanges === `function` && typeof opts.startSyncImmediate === `function` && typeof opts.id === `string`;
    if (isExistingCollection) {
      return opts;
    }
    if (typeof opts === `function`) {
      const queryBuilder = new db.BaseQueryBuilder();
      const result = opts(queryBuilder);
      if (result === void 0 || result === null) {
        return null;
      }
      return db.createLiveQueryCollection({
        query: opts,
        startSync: true,
        gcTime: 0
      });
    }
    const isReactiveQueryOptions = opts && typeof opts === `object` && typeof opts.query === `function` && typeof opts.params === `function`;
    if (isReactiveQueryOptions) {
      const { params, query } = opts;
      const currentParams = params();
      const queryBuilder = new db.BaseQueryBuilder();
      const result = query({ params: currentParams, q: queryBuilder });
      if (result === void 0 || result === null) {
        return null;
      }
      return db.createLiveQueryCollection({
        query: () => result,
        startSync: true,
        gcTime: 0
      });
    }
    if (opts && typeof opts === `object` && typeof opts.query === `function`) {
      return db.createLiveQueryCollection(opts);
    }
    throw new Error(`Invalid options provided to injectLiveQuery`);
  });
  const state = core.signal(/* @__PURE__ */ new Map());
  const internalData = core.signal([]);
  const status = core.signal(
    collection() ? `idle` : `disabled`
  );
  const data = core.computed(() => {
    const currentCollection = collection();
    if (!currentCollection) {
      return internalData();
    }
    const config = currentCollection.config;
    return config?.singleResult ? internalData()[0] : internalData();
  });
  const syncDataFromCollection = (currentCollection) => {
    const newState = new Map(currentCollection.entries());
    const newData = Array.from(currentCollection.values());
    state.set(newState);
    internalData.set(newData);
    status.set(currentCollection.status);
  };
  let unsub = null;
  const cleanup = () => {
    unsub?.();
    unsub = null;
  };
  core.effect((onCleanup) => {
    const currentCollection = collection();
    if (!currentCollection) {
      status.set(`disabled`);
      state.set(/* @__PURE__ */ new Map());
      internalData.set([]);
      cleanup();
      return;
    }
    cleanup();
    syncDataFromCollection(currentCollection);
    if (currentCollection.status === `idle`) {
      currentCollection.startSyncImmediate();
      status.set(currentCollection.status);
    }
    const subscription = currentCollection.subscribeChanges(
      (_) => {
        syncDataFromCollection(currentCollection);
      }
    );
    unsub = subscription.unsubscribe.bind(subscription);
    currentCollection.onFirstReady(() => {
      status.set(currentCollection.status);
    });
    onCleanup(cleanup);
  });
  destroyRef.onDestroy(cleanup);
  return {
    state,
    data,
    collection,
    status,
    isLoading: core.computed(() => status() === `loading`),
    isReady: core.computed(() => status() === `ready` || status() === `disabled`),
    isIdle: core.computed(() => status() === `idle`),
    isError: core.computed(() => status() === `error`),
    isCleanedUp: core.computed(() => status() === `cleaned-up`)
  };
}
exports.injectLiveQuery = injectLiveQuery;
Object.keys(db).forEach((k) => {
  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
    enumerable: true,
    get: () => db[k]
  });
});
//# sourceMappingURL=index.cjs.map