qortex-core 0.1.0

package/index.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Query key can be a string or readonly array of strings/numbers
+ * Using readonly to prevent accidental mutations
+ */
+type QueryKey = string | readonly (string | number)[];
+/** Valid query key values - only strings and numbers are allowed */
+type QueryKeyValue = string | number;
+/** Function that fetches data, can be async or sync */
+type Fetcher<T = any> = () => Promise<T> | T;
+/** Function that compares two values for equality */
+type EqualityFn<T = any> = (a: T | undefined, b: T | undefined) => boolean;
+/**
+ * Infers the resolved return type of a fetcher function
+ * Falls back to any for user-friendly experience
+ */
+type InferFetcherResult<F> = F extends (...args: any[]) => Promise<infer R> ? R : F extends (...args: any[]) => infer R ? R : any;
+/**
+ * Infers the return type of a fetcher, handling both sync and async cases
+ * Falls back to any for user-friendly experience
+ */
+type InferFetcherReturnType<T> = T extends Fetcher<infer R> ? R : any;
+/**
+ * Query status types for better type safety
+ */
+type QueryStatus = "idle" | "fetching" | "success" | "error";
+/**
+ * Comprehensive options for all query operations
+ * Improved with better type constraints
+ */
+type QueryOptions<T = any> = {
+    enabled?: boolean;
+    refetchOnSubscribe?: "always" | "stale" | false;
+    fetcher?: Fetcher<T>;
+    equalityFn?: EqualityFn<T>;
+    staleTime?: number;
+    signal?: AbortSignal;
+    placeholderData?: T;
+    usePreviousDataOnError?: boolean;
+    usePlaceholderOnError?: boolean;
+};
+/**
+ * Default configuration options that can be set globally
+ * Includes throttleTime which is not part of regular QueryOptions
+ */
+type DefaultConfig = {
+    enabled?: boolean;
+    refetchOnSubscribe?: "always" | "stale" | false;
+    staleTime?: number;
+    usePreviousDataOnError?: boolean;
+    usePlaceholderOnError?: boolean;
+    equalityFn?: EqualityFn<any>;
+    throttleTime?: number;
+};
+/**
+ * Public query state returned by getQueryState
+ * Improved with stricter error typing and better generic constraints
+ */
+type QueryState<T = any, E = Error> = {
+    data?: T;
+    error?: E;
+    status: QueryStatus;
+    updatedAt?: number;
+    isStale: boolean;
+    isPlaceholderData: boolean;
+    isLoading: boolean;
+    isFetching: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    refetch: () => Promise<T>;
+};
+
+/**
+ * Core query manager that handles caching, fetching, and state management
+ * Implements robust throttling and race condition prevention
+ */
+declare class QueryManager {
+    private cache;
+    private subs;
+    private lastReturnedState;
+    private defaultConfig;
+    private throttleTime;
+    /**
+     * Set default configuration for all queries
+     */
+    setDefaultConfig({ throttleTime, ...config }: DefaultConfig): void;
+    /**
+     * Ensures a query state exists in cache, creating it if necessary
+     * User-friendly with any fallback for better developer experience
+     */
+    private ensureState;
+    /**
+     * Notifies all subscribers of a query state change
+     */
+    private emit;
+    /**
+    * Registers a fetcher function for a query key
+    * Automatically fetches if enabled is not false
+    * Enhanced with automatic type inference from fetcher
+    */
+    registerFetcher<T = any>(key: QueryKey, opts: QueryOptions<T>): void;
+    registerFetcher<F extends Fetcher>(key: QueryKey, opts: QueryOptions<InferFetcherResult<F>> & {
+        fetcher: F;
+    }): void;
+    /**
+    * Executes a fetch operation with proper error handling and state management
+    * Prevents duplicate fetches
+    * Enhanced with automatic type inference from fetcher
+    */
+    fetchQuery<T = any>(key: QueryKey, opts?: QueryOptions<T>): Promise<T>;
+    fetchQuery<F extends Fetcher>(key: QueryKey, opts: QueryOptions<InferFetcherResult<F>> & {
+        fetcher: F;
+    }): Promise<InferFetcherResult<F>>;
+    /**
+     * Manually sets query data without triggering a fetch
+     * Marks query as successful
+     */
+    setQueryData<T = any>(key: QueryKey, data: T): void;
+    /**
+     * Gets query data
+     * Handles mount logic to potentially start fetching
+     */
+    getQueryData<T = any>(key: QueryKey, opts?: QueryOptions<T>): T | undefined;
+    /**
+     * Gets comprehensive query state including computed flags
+     * Handles placeholder data and error states appropriately
+     * Handles mount logic to potentially start fetching
+     */
+    getQueryState<T = unknown>(key: QueryKey, opts?: QueryOptions<T>): QueryState<T>;
+    /**
+     * Marks a query as invalidated, triggering refetch
+     */
+    invalidateQuery(key: QueryKey): void;
+    /**
+     * Subscribes to query state changes with automatic subscription management
+     * Handles mount logic to potentially start fetching
+     */
+    subscribeQuery<T = any>(key: QueryKey, cb: () => void, opts?: QueryOptions<T>): () => void;
+    /**
+     * Core mount logic that determines when to fetch
+     * Implements robust throttling and race condition prevention
+     */
+    private handleMountLogic;
+}
+declare const queryManager: QueryManager;
+
+/**
+ * Normalizes query keys to a consistent string format for internal storage
+ * Arrays are joined with commas, primitives are converted to strings
+ */
+declare function serializeKey(key: QueryKey): string;
+
+export { DefaultConfig, EqualityFn, Fetcher, InferFetcherResult, InferFetcherReturnType, QueryKey, QueryKeyValue, QueryManager, QueryOptions, QueryState, QueryStatus, queryManager, serializeKey };

package/index.js

@@ -0,0 +1,296 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  QueryManager: () => QueryManager,
+  queryManager: () => queryManager,
+  serializeKey: () => serializeKey
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/constants.ts
+var DEFAULT_STALE_TIME = 0;
+var THROTTLE_TIME = 50;
+
+// src/utils.ts
+function serializeKey(key) {
+  return Array.isArray(key) ? key.join(",") : String(key);
+}
+function shallowEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a == null || b == null)
+    return a === b;
+  if (typeof a !== "object" || typeof b !== "object")
+    return false;
+  try {
+    const aAny = a;
+    const bAny = b;
+    const aKeys = Object.keys(aAny);
+    const bKeys = Object.keys(bAny);
+    if (aKeys.length !== bKeys.length)
+      return false;
+    for (let i = 0; i < aKeys.length; i++) {
+      const k = aKeys[i];
+      if (aAny[k] !== bAny[k])
+        return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createDefaultState(opts, refetch) {
+  return {
+    status: "idle",
+    updatedAt: void 0,
+    staleTime: opts?.staleTime ?? DEFAULT_STALE_TIME,
+    isInvalidated: false,
+    fetcher: opts?.fetcher,
+    equalityFn: opts?.equalityFn ?? shallowEqual,
+    placeholderData: opts?.placeholderData,
+    usePreviousDataOnError: opts?.usePreviousDataOnError ?? false,
+    usePlaceholderOnError: opts?.usePlaceholderOnError ?? false,
+    refetchOnSubscribe: opts?.refetchOnSubscribe ?? "stale",
+    enabled: opts?.enabled === false ? false : true,
+    refetch: refetch || (() => Promise.resolve(void 0))
+  };
+}
+
+// src/queryManager.ts
+var QueryManager = class {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+    this.subs = /* @__PURE__ */ new Map();
+    this.lastReturnedState = /* @__PURE__ */ new Map();
+    this.defaultConfig = {};
+    this.throttleTime = THROTTLE_TIME;
+  }
+  /**
+   * Set default configuration for all queries
+   */
+  setDefaultConfig({ throttleTime, ...config }) {
+    this.defaultConfig = { ...this.defaultConfig, ...config };
+    if (throttleTime !== void 0) {
+      this.throttleTime = throttleTime;
+    }
+  }
+  /**
+   * Ensures a query state exists in cache, creating it if necessary
+   * User-friendly with any fallback for better developer experience
+   */
+  ensureState(key, opts = {}) {
+    const sk = serializeKey(key);
+    const state = this.cache.get(sk);
+    const mergedOpts = { ...this.defaultConfig, ...opts };
+    if (state) {
+      Object.assign(state, mergedOpts);
+      state.enabled = mergedOpts.enabled === false ? false : true;
+      this.cache.set(sk, state);
+    } else {
+      const newState = createDefaultState(mergedOpts, () => this.fetchQuery(key));
+      this.cache.set(sk, newState);
+    }
+    return this.cache.get(sk);
+  }
+  /**
+   * Notifies all subscribers of a query state change
+   */
+  emit(key, state) {
+    this.cache.set(serializeKey(key), state);
+    const set = this.subs.get(serializeKey(key));
+    if (!set)
+      return;
+    for (const cb of Array.from(set))
+      cb();
+  }
+  registerFetcher(key, opts) {
+    this.ensureState(key, opts);
+    if (opts.enabled !== false) {
+      try {
+        void this.fetchQuery(key);
+      } catch {
+      }
+    }
+  }
+  fetchQuery(key, opts) {
+    const state = this.ensureState(key, opts);
+    if (state.fetchPromise)
+      return state.fetchPromise;
+    const fetcher = state.fetcher;
+    if (!fetcher) {
+      console.error("No fetcher found for key", key);
+      return Promise.resolve(state.data);
+    }
+    ;
+    state.status = "fetching";
+    state.lastFetchTime = Date.now();
+    this.emit(key, state);
+    const result = fetcher();
+    const promise = Promise.resolve(result);
+    state.fetchPromise = promise;
+    promise.then((result2) => {
+      state.data = result2;
+      state.status = "success";
+      state.updatedAt = Date.now();
+    }).catch((error) => {
+      state.error = error;
+      state.status = "error";
+    }).finally(() => {
+      state.fetchPromise = void 0;
+      this.emit(key, state);
+    });
+    return promise;
+  }
+  /**
+   * Manually sets query data without triggering a fetch
+   * Marks query as successful
+   */
+  setQueryData(key, data) {
+    const state = this.ensureState(key);
+    const old = state.data;
+    if (state.equalityFn(old, data))
+      return;
+    state.data = data;
+    state.updatedAt = Date.now();
+    state.error = void 0;
+    state.status = "success";
+    state.isInvalidated = false;
+    this.emit(key, state);
+  }
+  /**
+   * Gets query data
+   * Handles mount logic to potentially start fetching
+   */
+  getQueryData(key, opts) {
+    const state = this.ensureState(key, opts);
+    this.handleMountLogic(key, state);
+    return state.data ?? state.placeholderData;
+  }
+  /**
+   * Gets comprehensive query state including computed flags
+   * Handles placeholder data and error states appropriately
+   * Handles mount logic to potentially start fetching
+   */
+  getQueryState(key, opts) {
+    let state = this.ensureState(key, opts);
+    const now = Date.now();
+    const isStale = state.updatedAt == null || now - (state.updatedAt || 0) > state.staleTime || state.isInvalidated;
+    let returnedData = state.data;
+    let isPlaceholderData = false;
+    const status = state.status;
+    switch (status) {
+      case "error":
+        if (state.usePlaceholderOnError && state.placeholderData !== void 0) {
+          returnedData = state.placeholderData;
+          isPlaceholderData = true;
+        }
+        break;
+      case "fetching":
+        if (!state.data && state.placeholderData) {
+          returnedData = state.placeholderData;
+          isPlaceholderData = true;
+        }
+        break;
+      case "success":
+      case "idle":
+        returnedData = state.data ?? state.placeholderData;
+        isPlaceholderData = state.data ? false : Boolean(state.placeholderData);
+        break;
+    }
+    this.handleMountLogic(key, state);
+    const currentState = {
+      data: returnedData,
+      error: state.error,
+      status: state.status,
+      updatedAt: state.updatedAt,
+      isStale,
+      isPlaceholderData,
+      isLoading: state.status === "fetching" && !state.updatedAt,
+      // true only for first fetch
+      isFetching: state.status === "fetching",
+      isError: state.status === "error",
+      isSuccess: state.status === "success",
+      refetch: state.refetch
+    };
+    const stateKey = serializeKey(key);
+    const lastState = this.lastReturnedState?.get(stateKey);
+    if (!lastState || !shallowEqual(lastState, currentState)) {
+      if (!this.lastReturnedState)
+        this.lastReturnedState = /* @__PURE__ */ new Map();
+      this.lastReturnedState.set(stateKey, currentState);
+      return currentState;
+    }
+    return lastState;
+  }
+  /**
+   * Marks a query as invalidated, triggering refetch
+   */
+  invalidateQuery(key) {
+    const state = this.ensureState(key);
+    state.isInvalidated = true;
+    this.emit(key, state);
+    this.fetchQuery(key);
+  }
+  /**
+   * Subscribes to query state changes with automatic subscription management
+   * Handles mount logic to potentially start fetching
+   */
+  subscribeQuery(key, cb, opts) {
+    const sk = serializeKey(key);
+    const state = this.ensureState(key, opts);
+    if (!this.subs.has(sk))
+      this.subs.set(sk, /* @__PURE__ */ new Set());
+    this.subs.get(sk).add(cb);
+    this.handleMountLogic(key, state);
+    return () => {
+      this.subs.get(sk).delete(cb);
+    };
+  }
+  /**
+   * Core mount logic that determines when to fetch
+   * Implements robust throttling and race condition prevention
+   */
+  handleMountLogic(key, state) {
+    const isThrottled = state.lastFetchTime && Date.now() - state.lastFetchTime < this.throttleTime;
+    if (state?.status === "fetching" || !state?.enabled || isThrottled || !state?.fetcher)
+      return;
+    const now = Date.now();
+    const isStale = state?.updatedAt == null || now - (state.updatedAt || 0) > state.staleTime || state.isInvalidated;
+    let shouldRefetch = false;
+    if (state.refetchOnSubscribe === "always") {
+      shouldRefetch = true;
+    }
+    if (state.refetchOnSubscribe === "stale") {
+      shouldRefetch = isStale;
+    }
+    if (shouldRefetch) {
+      this.fetchQuery(key);
+    }
+  }
+};
+var queryManager = new QueryManager();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QueryManager,
+  queryManager,
+  serializeKey
+});

package/index.mjs

@@ -0,0 +1,267 @@
+// src/constants.ts
+var DEFAULT_STALE_TIME = 0;
+var THROTTLE_TIME = 50;
+
+// src/utils.ts
+function serializeKey(key) {
+  return Array.isArray(key) ? key.join(",") : String(key);
+}
+function shallowEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a == null || b == null)
+    return a === b;
+  if (typeof a !== "object" || typeof b !== "object")
+    return false;
+  try {
+    const aAny = a;
+    const bAny = b;
+    const aKeys = Object.keys(aAny);
+    const bKeys = Object.keys(bAny);
+    if (aKeys.length !== bKeys.length)
+      return false;
+    for (let i = 0; i < aKeys.length; i++) {
+      const k = aKeys[i];
+      if (aAny[k] !== bAny[k])
+        return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createDefaultState(opts, refetch) {
+  return {
+    status: "idle",
+    updatedAt: void 0,
+    staleTime: opts?.staleTime ?? DEFAULT_STALE_TIME,
+    isInvalidated: false,
+    fetcher: opts?.fetcher,
+    equalityFn: opts?.equalityFn ?? shallowEqual,
+    placeholderData: opts?.placeholderData,
+    usePreviousDataOnError: opts?.usePreviousDataOnError ?? false,
+    usePlaceholderOnError: opts?.usePlaceholderOnError ?? false,
+    refetchOnSubscribe: opts?.refetchOnSubscribe ?? "stale",
+    enabled: opts?.enabled === false ? false : true,
+    refetch: refetch || (() => Promise.resolve(void 0))
+  };
+}
+
+// src/queryManager.ts
+var QueryManager = class {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+    this.subs = /* @__PURE__ */ new Map();
+    this.lastReturnedState = /* @__PURE__ */ new Map();
+    this.defaultConfig = {};
+    this.throttleTime = THROTTLE_TIME;
+  }
+  /**
+   * Set default configuration for all queries
+   */
+  setDefaultConfig({ throttleTime, ...config }) {
+    this.defaultConfig = { ...this.defaultConfig, ...config };
+    if (throttleTime !== void 0) {
+      this.throttleTime = throttleTime;
+    }
+  }
+  /**
+   * Ensures a query state exists in cache, creating it if necessary
+   * User-friendly with any fallback for better developer experience
+   */
+  ensureState(key, opts = {}) {
+    const sk = serializeKey(key);
+    const state = this.cache.get(sk);
+    const mergedOpts = { ...this.defaultConfig, ...opts };
+    if (state) {
+      Object.assign(state, mergedOpts);
+      state.enabled = mergedOpts.enabled === false ? false : true;
+      this.cache.set(sk, state);
+    } else {
+      const newState = createDefaultState(mergedOpts, () => this.fetchQuery(key));
+      this.cache.set(sk, newState);
+    }
+    return this.cache.get(sk);
+  }
+  /**
+   * Notifies all subscribers of a query state change
+   */
+  emit(key, state) {
+    this.cache.set(serializeKey(key), state);
+    const set = this.subs.get(serializeKey(key));
+    if (!set)
+      return;
+    for (const cb of Array.from(set))
+      cb();
+  }
+  registerFetcher(key, opts) {
+    this.ensureState(key, opts);
+    if (opts.enabled !== false) {
+      try {
+        void this.fetchQuery(key);
+      } catch {
+      }
+    }
+  }
+  fetchQuery(key, opts) {
+    const state = this.ensureState(key, opts);
+    if (state.fetchPromise)
+      return state.fetchPromise;
+    const fetcher = state.fetcher;
+    if (!fetcher) {
+      console.error("No fetcher found for key", key);
+      return Promise.resolve(state.data);
+    }
+    ;
+    state.status = "fetching";
+    state.lastFetchTime = Date.now();
+    this.emit(key, state);
+    const result = fetcher();
+    const promise = Promise.resolve(result);
+    state.fetchPromise = promise;
+    promise.then((result2) => {
+      state.data = result2;
+      state.status = "success";
+      state.updatedAt = Date.now();
+    }).catch((error) => {
+      state.error = error;
+      state.status = "error";
+    }).finally(() => {
+      state.fetchPromise = void 0;
+      this.emit(key, state);
+    });
+    return promise;
+  }
+  /**
+   * Manually sets query data without triggering a fetch
+   * Marks query as successful
+   */
+  setQueryData(key, data) {
+    const state = this.ensureState(key);
+    const old = state.data;
+    if (state.equalityFn(old, data))
+      return;
+    state.data = data;
+    state.updatedAt = Date.now();
+    state.error = void 0;
+    state.status = "success";
+    state.isInvalidated = false;
+    this.emit(key, state);
+  }
+  /**
+   * Gets query data
+   * Handles mount logic to potentially start fetching
+   */
+  getQueryData(key, opts) {
+    const state = this.ensureState(key, opts);
+    this.handleMountLogic(key, state);
+    return state.data ?? state.placeholderData;
+  }
+  /**
+   * Gets comprehensive query state including computed flags
+   * Handles placeholder data and error states appropriately
+   * Handles mount logic to potentially start fetching
+   */
+  getQueryState(key, opts) {
+    let state = this.ensureState(key, opts);
+    const now = Date.now();
+    const isStale = state.updatedAt == null || now - (state.updatedAt || 0) > state.staleTime || state.isInvalidated;
+    let returnedData = state.data;
+    let isPlaceholderData = false;
+    const status = state.status;
+    switch (status) {
+      case "error":
+        if (state.usePlaceholderOnError && state.placeholderData !== void 0) {
+          returnedData = state.placeholderData;
+          isPlaceholderData = true;
+        }
+        break;
+      case "fetching":
+        if (!state.data && state.placeholderData) {
+          returnedData = state.placeholderData;
+          isPlaceholderData = true;
+        }
+        break;
+      case "success":
+      case "idle":
+        returnedData = state.data ?? state.placeholderData;
+        isPlaceholderData = state.data ? false : Boolean(state.placeholderData);
+        break;
+    }
+    this.handleMountLogic(key, state);
+    const currentState = {
+      data: returnedData,
+      error: state.error,
+      status: state.status,
+      updatedAt: state.updatedAt,
+      isStale,
+      isPlaceholderData,
+      isLoading: state.status === "fetching" && !state.updatedAt,
+      // true only for first fetch
+      isFetching: state.status === "fetching",
+      isError: state.status === "error",
+      isSuccess: state.status === "success",
+      refetch: state.refetch
+    };
+    const stateKey = serializeKey(key);
+    const lastState = this.lastReturnedState?.get(stateKey);
+    if (!lastState || !shallowEqual(lastState, currentState)) {
+      if (!this.lastReturnedState)
+        this.lastReturnedState = /* @__PURE__ */ new Map();
+      this.lastReturnedState.set(stateKey, currentState);
+      return currentState;
+    }
+    return lastState;
+  }
+  /**
+   * Marks a query as invalidated, triggering refetch
+   */
+  invalidateQuery(key) {
+    const state = this.ensureState(key);
+    state.isInvalidated = true;
+    this.emit(key, state);
+    this.fetchQuery(key);
+  }
+  /**
+   * Subscribes to query state changes with automatic subscription management
+   * Handles mount logic to potentially start fetching
+   */
+  subscribeQuery(key, cb, opts) {
+    const sk = serializeKey(key);
+    const state = this.ensureState(key, opts);
+    if (!this.subs.has(sk))
+      this.subs.set(sk, /* @__PURE__ */ new Set());
+    this.subs.get(sk).add(cb);
+    this.handleMountLogic(key, state);
+    return () => {
+      this.subs.get(sk).delete(cb);
+    };
+  }
+  /**
+   * Core mount logic that determines when to fetch
+   * Implements robust throttling and race condition prevention
+   */
+  handleMountLogic(key, state) {
+    const isThrottled = state.lastFetchTime && Date.now() - state.lastFetchTime < this.throttleTime;
+    if (state?.status === "fetching" || !state?.enabled || isThrottled || !state?.fetcher)
+      return;
+    const now = Date.now();
+    const isStale = state?.updatedAt == null || now - (state.updatedAt || 0) > state.staleTime || state.isInvalidated;
+    let shouldRefetch = false;
+    if (state.refetchOnSubscribe === "always") {
+      shouldRefetch = true;
+    }
+    if (state.refetchOnSubscribe === "stale") {
+      shouldRefetch = isStale;
+    }
+    if (shouldRefetch) {
+      this.fetchQuery(key);
+    }
+  }
+};
+var queryManager = new QueryManager();
+export {
+  QueryManager,
+  queryManager,
+  serializeKey
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "qortex-core",
+  "version": "0.1.0",
+  "description": "Framework-agnostic query cache & fetch registry (MFE friendly).",
+  "main": "index.js",
+  "module": "index.mjs",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.mjs",
+      "require": "./index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "index.js",
+    "index.mjs",
+    "index.d.ts",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Darshan-Naik/qortex.git"
+  },
+  "homepage": "https://github.com/Darshan-Naik/qortex#readme",
+  "bugs": {
+    "url": "https://github.com/Darshan-Naik/qortex/issues"
+  },
+  "keywords": [
+    "qortex",
+    "query",
+    "cache",
+    "runtime",
+    "mfe",
+    "data-fetching",
+    "typescript"
+  ],
+  "author": "Darshan Naik",
+  "license": "MIT",
+  "dependencies": {},
+  "peerDependencies": {}
+}