var __CODE__ = (() => { var __create = Object.create; var __defProp = Object.defineProperty; var __getOwnPropDesc = Object.getOwnPropertyDescriptor; var __getOwnPropNames = Object.getOwnPropertyNames; var __getProtoOf = Object.getPrototypeOf; var __hasOwnProp = Object.prototype.hasOwnProperty; var __esm = (fn, res) => function __init() { return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; }; var __commonJS = (cb, mod) => function __require() { return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; }; 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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( // If the importer is in node compatibility mode or this is not an ESM // file that has been converted to a CommonJS file using a Babel- // compatible transform (i.e. "__esModule" has not been set), then set // "default" to the CommonJS "module.exports" for node compatibility. isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod )); var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); // virtual:/__injected-globals.js var fetch; var init_injected_globals = __esm({ "virtual:/__injected-globals.js"() { fetch = /* @__PURE__ */ (function(originalFetch) { const getURlFromArgs = (...args) => { const [urlArg] = args; let url; if (typeof urlArg === "string") { url = urlArg; } else if (urlArg instanceof Request) { url = urlArg.url; } else { url = `${urlArg.protocol}//${urlArg.host}${urlArg.pathname}`; } return url; }; const isFirstPartyURL = (url) => { return url.startsWith(window.location.origin) || url.startsWith("/") || url.startsWith("https://created.app"); }; return async function fetchWithHeaders(input, init = {}) { const url = getURlFromArgs(input, init); const isExternalFetch = !isFirstPartyURL(url); if (isExternalFetch) { return originalFetch(input, init); } const initHeaders = init?.headers ?? {}; const finalHeaders = new Headers(initHeaders); finalHeaders.set("x-createxyz-project-id", "fbd4e9a9-c70d-4385-b809-168f0a13e002"); finalHeaders.set("x-createxyz-project-group-id", "c00c0a4b-3599-4e9c-ad20-8798bdc07b56"); if (input instanceof Request) { input.headers.set("x-createxyz-project-id", "fbd4e9a9-c70d-4385-b809-168f0a13e002"); input.headers.set("x-createxyz-project-group-id", "c00c0a4b-3599-4e9c-ad20-8798bdc07b56"); } return originalFetch(input, { ...init, headers: finalHeaders }); }; })(globalThis.fetch); } }); // global-externals:react var require_react = __commonJS({ "global-externals:react"(exports, module) { init_injected_globals(); module.exports = React; } }); // ../../../node_modules/react/cjs/react-jsx-runtime.production.min.js var require_react_jsx_runtime_production_min = __commonJS({ "../../../node_modules/react/cjs/react-jsx-runtime.production.min.js"(exports) { "use strict"; init_injected_globals(); var f = require_react(); var k = Symbol.for("react.element"); var l = Symbol.for("react.fragment"); var m = Object.prototype.hasOwnProperty; var n = f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner; var p = { key: true, ref: true, __self: true, __source: true }; function q(c, a, g) { var b, d = {}, e = null, h = null; void 0 !== g && (e = "" + g); void 0 !== a.key && (e = "" + a.key); void 0 !== a.ref && (h = a.ref); for (b in a) m.call(a, b) && !p.hasOwnProperty(b) && (d[b] = a[b]); if (c && c.defaultProps) for (b in a = c.defaultProps, a) void 0 === d[b] && (d[b] = a[b]); return { $$typeof: k, type: c, key: e, ref: h, props: d, _owner: n.current }; } exports.Fragment = l; exports.jsx = q; exports.jsxs = q; } }); // ../../../node_modules/react/jsx-runtime.js var require_jsx_runtime = __commonJS({ "../../../node_modules/react/jsx-runtime.js"(exports, module) { "use strict"; init_injected_globals(); if (true) { module.exports = require_react_jsx_runtime_production_min(); } else { module.exports = null; } } }); // virtual:/__wrapped_entry__.jsx var wrapped_entry_exports = {}; __export(wrapped_entry_exports, { default: () => WrappedPage }); init_injected_globals(); var import_react7 = __toESM(require_react()); // virtual:/apps/web/src/app/dashboard/page.jsx init_injected_globals(); var import_react4 = __toESM(require_react()); // virtual:/apps/web/src/utils/useUser.js init_injected_globals(); var React8 = __toESM(require_react()); // ../../../node_modules/@tanstack/react-query/build/modern/index.js init_injected_globals(); // ../../../node_modules/@tanstack/query-core/build/modern/index.js init_injected_globals(); // ../../../node_modules/@tanstack/query-core/build/modern/retryer.js init_injected_globals(); // ../../../node_modules/@tanstack/query-core/build/modern/focusManager.js init_injected_globals(); // ../../../node_modules/@tanstack/query-core/build/modern/subscribable.js init_injected_globals(); var Subscribable = class { constructor() { this.listeners = /* @__PURE__ */ new Set(); this.subscribe = this.subscribe.bind(this); } subscribe(listener) { this.listeners.add(listener); this.onSubscribe(); return () => { this.listeners.delete(listener); this.onUnsubscribe(); }; } hasListeners() { return this.listeners.size > 0; } onSubscribe() { } onUnsubscribe() { } }; // ../../../node_modules/@tanstack/query-core/build/modern/utils.js init_injected_globals(); var isServer = typeof window === "undefined" || "Deno" in globalThis; function noop() { } function functionalUpdate(updater, input) { return typeof updater === "function" ? updater(input) : updater; } function isValidTimeout(value) { return typeof value === "number" && value >= 0 && value !== Infinity; } function timeUntilStale(updatedAt, staleTime) { return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0); } function resolveStaleTime(staleTime, query) { return typeof staleTime === "function" ? staleTime(query) : staleTime; } function resolveEnabled(enabled, query) { return typeof enabled === "function" ? enabled(query) : enabled; } function matchQuery(filters, query) { const { type = "all", exact, fetchStatus, predicate, queryKey, stale } = filters; if (queryKey) { if (exact) { if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) { return false; } } else if (!partialMatchKey(query.queryKey, queryKey)) { return false; } } if (type !== "all") { const isActive = query.isActive(); if (type === "active" && !isActive) { return false; } if (type === "inactive" && isActive) { return false; } } if (typeof stale === "boolean" && query.isStale() !== stale) { return false; } if (fetchStatus && fetchStatus !== query.state.fetchStatus) { return false; } if (predicate && !predicate(query)) { return false; } return true; } function matchMutation(filters, mutation) { const { exact, status, predicate, mutationKey } = filters; if (mutationKey) { if (!mutation.options.mutationKey) { return false; } if (exact) { if (hashKey(mutation.options.mutationKey) !== hashKey(mutationKey)) { return false; } } else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) { return false; } } if (status && mutation.state.status !== status) { return false; } if (predicate && !predicate(mutation)) { return false; } return true; } function hashQueryKeyByOptions(queryKey, options) { const hashFn = options?.queryKeyHashFn || hashKey; return hashFn(queryKey); } function hashKey(queryKey) { return JSON.stringify( queryKey, (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => { result[key] = val[key]; return result; }, {}) : val ); } function partialMatchKey(a, b) { if (a === b) { return true; } if (typeof a !== typeof b) { return false; } if (a && b && typeof a === "object" && typeof b === "object") { return Object.keys(b).every((key) => partialMatchKey(a[key], b[key])); } return false; } function replaceEqualDeep(a, b) { if (a === b) { return a; } const array = isPlainArray(a) && isPlainArray(b); if (array || isPlainObject(a) && isPlainObject(b)) { const aItems = array ? a : Object.keys(a); const aSize = aItems.length; const bItems = array ? b : Object.keys(b); const bSize = bItems.length; const copy = array ? [] : {}; let equalItems = 0; for (let i = 0; i < bSize; i++) { const key = array ? i : bItems[i]; if ((!array && aItems.includes(key) || array) && a[key] === void 0 && b[key] === void 0) { copy[key] = void 0; equalItems++; } else { copy[key] = replaceEqualDeep(a[key], b[key]); if (copy[key] === a[key] && a[key] !== void 0) { equalItems++; } } } return aSize === bSize && equalItems === aSize ? a : copy; } return b; } function shallowEqualObjects(a, b) { if (!b || Object.keys(a).length !== Object.keys(b).length) { return false; } for (const key in a) { if (a[key] !== b[key]) { return false; } } return true; } function isPlainArray(value) { return Array.isArray(value) && value.length === Object.keys(value).length; } function isPlainObject(o) { if (!hasObjectPrototype(o)) { return false; } const ctor = o.constructor; if (ctor === void 0) { return true; } const prot = ctor.prototype; if (!hasObjectPrototype(prot)) { return false; } if (!prot.hasOwnProperty("isPrototypeOf")) { return false; } if (Object.getPrototypeOf(o) !== Object.prototype) { return false; } return true; } function hasObjectPrototype(o) { return Object.prototype.toString.call(o) === "[object Object]"; } function sleep(timeout) { return new Promise((resolve) => { setTimeout(resolve, timeout); }); } function replaceData(prevData, data, options) { if (typeof options.structuralSharing === "function") { return options.structuralSharing(prevData, data); } else if (options.structuralSharing !== false) { if (false) { try { return replaceEqualDeep(prevData, data); } catch (error) { console.error( `Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${options.queryHash}]: ${error}` ); throw error; } } return replaceEqualDeep(prevData, data); } return data; } function addToEnd(items, item, max2 = 0) { const newItems = [...items, item]; return max2 && newItems.length > max2 ? newItems.slice(1) : newItems; } function addToStart(items, item, max2 = 0) { const newItems = [item, ...items]; return max2 && newItems.length > max2 ? newItems.slice(0, -1) : newItems; } var skipToken = Symbol(); function ensureQueryFn(options, fetchOptions) { if (false) { if (options.queryFn === skipToken) { console.error( `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${options.queryHash}'` ); } } if (!options.queryFn && fetchOptions?.initialPromise) { return () => fetchOptions.initialPromise; } if (!options.queryFn || options.queryFn === skipToken) { return () => Promise.reject(new Error(`Missing queryFn: '${options.queryHash}'`)); } return options.queryFn; } // ../../../node_modules/@tanstack/query-core/build/modern/focusManager.js var FocusManager = class extends Subscribable { #focused; #cleanup; #setup; constructor() { super(); this.#setup = (onFocus) => { if (!isServer && window.addEventListener) { const listener = () => onFocus(); window.addEventListener("visibilitychange", listener, false); return () => { window.removeEventListener("visibilitychange", listener); }; } return; }; } onSubscribe() { if (!this.#cleanup) { this.setEventListener(this.#setup); } } onUnsubscribe() { if (!this.hasListeners()) { this.#cleanup?.(); this.#cleanup = void 0; } } setEventListener(setup) { this.#setup = setup; this.#cleanup?.(); this.#cleanup = setup((focused) => { if (typeof focused === "boolean") { this.setFocused(focused); } else { this.onFocus(); } }); } setFocused(focused) { const changed = this.#focused !== focused; if (changed) { this.#focused = focused; this.onFocus(); } } onFocus() { const isFocused = this.isFocused(); this.listeners.forEach((listener) => { listener(isFocused); }); } isFocused() { if (typeof this.#focused === "boolean") { return this.#focused; } return globalThis.document?.visibilityState !== "hidden"; } }; var focusManager = new FocusManager(); // ../../../node_modules/@tanstack/query-core/build/modern/onlineManager.js init_injected_globals(); var OnlineManager = class extends Subscribable { #online = true; #cleanup; #setup; constructor() { super(); this.#setup = (onOnline) => { if (!isServer && window.addEventListener) { const onlineListener = () => onOnline(true); const offlineListener = () => onOnline(false); window.addEventListener("online", onlineListener, false); window.addEventListener("offline", offlineListener, false); return () => { window.removeEventListener("online", onlineListener); window.removeEventListener("offline", offlineListener); }; } return; }; } onSubscribe() { if (!this.#cleanup) { this.setEventListener(this.#setup); } } onUnsubscribe() { if (!this.hasListeners()) { this.#cleanup?.(); this.#cleanup = void 0; } } setEventListener(setup) { this.#setup = setup; this.#cleanup?.(); this.#cleanup = setup(this.setOnline.bind(this)); } setOnline(online) { const changed = this.#online !== online; if (changed) { this.#online = online; this.listeners.forEach((listener) => { listener(online); }); } } isOnline() { return this.#online; } }; var onlineManager = new OnlineManager(); // ../../../node_modules/@tanstack/query-core/build/modern/thenable.js init_injected_globals(); function pendingThenable() { let resolve; let reject; const thenable = new Promise((_resolve, _reject) => { resolve = _resolve; reject = _reject; }); thenable.status = "pending"; thenable.catch(() => { }); function finalize(data) { Object.assign(thenable, data); delete thenable.resolve; delete thenable.reject; } thenable.resolve = (value) => { finalize({ status: "fulfilled", value }); resolve(value); }; thenable.reject = (reason) => { finalize({ status: "rejected", reason }); reject(reason); }; return thenable; } // ../../../node_modules/@tanstack/query-core/build/modern/retryer.js function defaultRetryDelay(failureCount) { return Math.min(1e3 * 2 ** failureCount, 3e4); } function canFetch(networkMode) { return (networkMode ?? "online") === "online" ? onlineManager.isOnline() : true; } var CancelledError = class extends Error { constructor(options) { super("CancelledError"); this.revert = options?.revert; this.silent = options?.silent; } }; function isCancelledError(value) { return value instanceof CancelledError; } function createRetryer(config) { let isRetryCancelled = false; let failureCount = 0; let isResolved = false; let continueFn; const thenable = pendingThenable(); const cancel = (cancelOptions) => { if (!isResolved) { reject(new CancelledError(cancelOptions)); config.abort?.(); } }; const cancelRetry = () => { isRetryCancelled = true; }; const continueRetry = () => { isRetryCancelled = false; }; const canContinue = () => focusManager.isFocused() && (config.networkMode === "always" || onlineManager.isOnline()) && config.canRun(); const canStart = () => canFetch(config.networkMode) && config.canRun(); const resolve = (value) => { if (!isResolved) { isResolved = true; config.onSuccess?.(value); continueFn?.(); thenable.resolve(value); } }; const reject = (value) => { if (!isResolved) { isResolved = true; config.onError?.(value); continueFn?.(); thenable.reject(value); } }; const pause = () => { return new Promise((continueResolve) => { continueFn = (value) => { if (isResolved || canContinue()) { continueResolve(value); } }; config.onPause?.(); }).then(() => { continueFn = void 0; if (!isResolved) { config.onContinue?.(); } }); }; const run = () => { if (isResolved) { return; } let promiseOrValue; const initialPromise = failureCount === 0 ? config.initialPromise : void 0; try { promiseOrValue = initialPromise ?? config.fn(); } catch (error) { promiseOrValue = Promise.reject(error); } Promise.resolve(promiseOrValue).then(resolve).catch((error) => { if (isResolved) { return; } const retry = config.retry ?? (isServer ? 0 : 3); const retryDelay = config.retryDelay ?? defaultRetryDelay; const delay = typeof retryDelay === "function" ? retryDelay(failureCount, error) : retryDelay; const shouldRetry = retry === true || typeof retry === "number" && failureCount < retry || typeof retry === "function" && retry(failureCount, error); if (isRetryCancelled || !shouldRetry) { reject(error); return; } failureCount++; config.onFail?.(failureCount, error); sleep(delay).then(() => { return canContinue() ? void 0 : pause(); }).then(() => { if (isRetryCancelled) { reject(error); } else { run(); } }); }); }; return { promise: thenable, cancel, continue: () => { continueFn?.(); return thenable; }, cancelRetry, continueRetry, canStart, start: () => { if (canStart()) { run(); } else { pause().then(run); } return thenable; } }; } // ../../../node_modules/@tanstack/query-core/build/modern/queryCache.js init_injected_globals(); // ../../../node_modules/@tanstack/query-core/build/modern/query.js init_injected_globals(); // ../../../node_modules/@tanstack/query-core/build/modern/notifyManager.js init_injected_globals(); var defaultScheduler = (cb) => setTimeout(cb, 0); function createNotifyManager() { let queue = []; let transactions = 0; let notifyFn = (callback) => { callback(); }; let batchNotifyFn = (callback) => { callback(); }; let scheduleFn = defaultScheduler; const schedule = (callback) => { if (transactions) { queue.push(callback); } else { scheduleFn(() => { notifyFn(callback); }); } }; const flush = () => { const originalQueue = queue; queue = []; if (originalQueue.length) { scheduleFn(() => { batchNotifyFn(() => { originalQueue.forEach((callback) => { notifyFn(callback); }); }); }); } }; return { batch: (callback) => { let result; transactions++; try { result = callback(); } finally { transactions--; if (!transactions) { flush(); } } return result; }, /** * All calls to the wrapped function will be batched. */ batchCalls: (callback) => { return (...args) => { schedule(() => { callback(...args); }); }; }, schedule, /** * Use this method to set a custom notify function. * This can be used to for example wrap notifications with `React.act` while running tests. */ setNotifyFunction: (fn) => { notifyFn = fn; }, /** * Use this method to set a custom function to batch notifications together into a single tick. * By default React Query will use the batch function provided by ReactDOM or React Native. */ setBatchNotifyFunction: (fn) => { batchNotifyFn = fn; }, setScheduler: (fn) => { scheduleFn = fn; } }; } var notifyManager = createNotifyManager(); // ../../../node_modules/@tanstack/query-core/build/modern/removable.js init_injected_globals(); var Removable = class { #gcTimeout; destroy() { this.clearGcTimeout(); } scheduleGc() { this.clearGcTimeout(); if (isValidTimeout(this.gcTime)) { this.#gcTimeout = setTimeout(() => { this.optionalRemove(); }, this.gcTime); } } updateGcTime(newGcTime) { this.gcTime = Math.max( this.gcTime || 0, newGcTime ?? (isServer ? Infinity : 5 * 60 * 1e3) ); } clearGcTimeout() { if (this.#gcTimeout) { clearTimeout(this.#gcTimeout); this.#gcTimeout = void 0; } } }; // ../../../node_modules/@tanstack/query-core/build/modern/query.js var Query = class extends Removable { #initialState; #revertState; #cache; #client; #retryer; #defaultOptions; #abortSignalConsumed; constructor(config) { super(); this.#abortSignalConsumed = false; this.#defaultOptions = config.defaultOptions; this.setOptions(config.options); this.observers = []; this.#client = config.client; this.#cache = this.#client.getQueryCache(); this.queryKey = config.queryKey; this.queryHash = config.queryHash; this.#initialState = getDefaultState(this.options); this.state = config.state ?? this.#initialState; this.scheduleGc(); } get meta() { return this.options.meta; } get promise() { return this.#retryer?.promise; } setOptions(options) { this.options = { ...this.#defaultOptions, ...options }; this.updateGcTime(this.options.gcTime); } optionalRemove() { if (!this.observers.length && this.state.fetchStatus === "idle") { this.#cache.remove(this); } } setData(newData, options) { const data = replaceData(this.state.data, newData, this.options); this.#dispatch({ data, type: "success", dataUpdatedAt: options?.updatedAt, manual: options?.manual }); return data; } setState(state, setStateOptions) { this.#dispatch({ type: "setState", state, setStateOptions }); } cancel(options) { const promise = this.#retryer?.promise; this.#retryer?.cancel(options); return promise ? promise.then(noop).catch(noop) : Promise.resolve(); } destroy() { super.destroy(); this.cancel({ silent: true }); } reset() { this.destroy(); this.setState(this.#initialState); } isActive() { return this.observers.some( (observer) => resolveEnabled(observer.options.enabled, this) !== false ); } isDisabled() { if (this.getObserversCount() > 0) { return !this.isActive(); } return this.options.queryFn === skipToken || this.state.dataUpdateCount + this.state.errorUpdateCount === 0; } isStale() { if (this.state.isInvalidated) { return true; } if (this.getObserversCount() > 0) { return this.observers.some( (observer) => observer.getCurrentResult().isStale ); } return this.state.data === void 0; } isStaleByTime(staleTime = 0) { return this.state.isInvalidated || this.state.data === void 0 || !timeUntilStale(this.state.dataUpdatedAt, staleTime); } onFocus() { const observer = this.observers.find((x) => x.shouldFetchOnWindowFocus()); observer?.refetch({ cancelRefetch: false }); this.#retryer?.continue(); } onOnline() { const observer = this.observers.find((x) => x.shouldFetchOnReconnect()); observer?.refetch({ cancelRefetch: false }); this.#retryer?.continue(); } addObserver(observer) { if (!this.observers.includes(observer)) { this.observers.push(observer); this.clearGcTimeout(); this.#cache.notify({ type: "observerAdded", query: this, observer }); } } removeObserver(observer) { if (this.observers.includes(observer)) { this.observers = this.observers.filter((x) => x !== observer); if (!this.observers.length) { if (this.#retryer) { if (this.#abortSignalConsumed) { this.#retryer.cancel({ revert: true }); } else { this.#retryer.cancelRetry(); } } this.scheduleGc(); } this.#cache.notify({ type: "observerRemoved", query: this, observer }); } } getObserversCount() { return this.observers.length; } invalidate() { if (!this.state.isInvalidated) { this.#dispatch({ type: "invalidate" }); } } fetch(options, fetchOptions) { if (this.state.fetchStatus !== "idle") { if (this.state.data !== void 0 && fetchOptions?.cancelRefetch) { this.cancel({ silent: true }); } else if (this.#retryer) { this.#retryer.continueRetry(); return this.#retryer.promise; } } if (options) { this.setOptions(options); } if (!this.options.queryFn) { const observer = this.observers.find((x) => x.options.queryFn); if (observer) { this.setOptions(observer.options); } } if (false) { if (!Array.isArray(this.options.queryKey)) { console.error( `As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']` ); } } const abortController = new AbortController(); const addSignalProperty = (object) => { Object.defineProperty(object, "signal", { enumerable: true, get: () => { this.#abortSignalConsumed = true; return abortController.signal; } }); }; const fetchFn = () => { const queryFn = ensureQueryFn(this.options, fetchOptions); const queryFnContext = { client: this.#client, queryKey: this.queryKey, meta: this.meta }; addSignalProperty(queryFnContext); this.#abortSignalConsumed = false; if (this.options.persister) { return this.options.persister( queryFn, queryFnContext, this ); } return queryFn(queryFnContext); }; const context = { fetchOptions, options: this.options, queryKey: this.queryKey, client: this.#client, state: this.state, fetchFn }; addSignalProperty(context); this.options.behavior?.onFetch( context, this ); this.#revertState = this.state; if (this.state.fetchStatus === "idle" || this.state.fetchMeta !== context.fetchOptions?.meta) { this.#dispatch({ type: "fetch", meta: context.fetchOptions?.meta }); } const onError = (error) => { if (!(isCancelledError(error) && error.silent)) { this.#dispatch({ type: "error", error }); } if (!isCancelledError(error)) { this.#cache.config.onError?.( error, this ); this.#cache.config.onSettled?.( this.state.data, error, this ); } this.scheduleGc(); }; this.#retryer = createRetryer({ initialPromise: fetchOptions?.initialPromise, fn: context.fetchFn, abort: abortController.abort.bind(abortController), onSuccess: (data) => { if (data === void 0) { if (false) { console.error( `Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}` ); } onError(new Error(`${this.queryHash} data is undefined`)); return; } try { this.setData(data); } catch (error) { onError(error); return; } this.#cache.config.onSuccess?.(data, this); this.#cache.config.onSettled?.( data, this.state.error, this ); this.scheduleGc(); }, onError, onFail: (failureCount, error) => { this.#dispatch({ type: "failed", failureCount, error }); }, onPause: () => { this.#dispatch({ type: "pause" }); }, onContinue: () => { this.#dispatch({ type: "continue" }); }, retry: context.options.retry, retryDelay: context.options.retryDelay, networkMode: context.options.networkMode, canRun: () => true }); return this.#retryer.start(); } #dispatch(action) { const reducer = (state) => { switch (action.type) { case "failed": return { ...state, fetchFailureCount: action.failureCount, fetchFailureReason: action.error }; case "pause": return { ...state, fetchStatus: "paused" }; case "continue": return { ...state, fetchStatus: "fetching" }; case "fetch": return { ...state, ...fetchState(state.data, this.options), fetchMeta: action.meta ?? null }; case "success": return { ...state, data: action.data, dataUpdateCount: state.dataUpdateCount + 1, dataUpdatedAt: action.dataUpdatedAt ?? Date.now(), error: null, isInvalidated: false, status: "success", ...!action.manual && { fetchStatus: "idle", fetchFailureCount: 0, fetchFailureReason: null } }; case "error": const error = action.error; if (isCancelledError(error) && error.revert && this.#revertState) { return { ...this.#revertState, fetchStatus: "idle" }; } return { ...state, error, errorUpdateCount: state.errorUpdateCount + 1, errorUpdatedAt: Date.now(), fetchFailureCount: state.fetchFailureCount + 1, fetchFailureReason: error, fetchStatus: "idle", status: "error" }; case "invalidate": return { ...state, isInvalidated: true }; case "setState": return { ...state, ...action.state }; } }; this.state = reducer(this.state); notifyManager.batch(() => { this.observers.forEach((observer) => { observer.onQueryUpdate(); }); this.#cache.notify({ query: this, type: "updated", action }); }); } }; function fetchState(data, options) { return { fetchFailureCount: 0, fetchFailureReason: null, fetchStatus: canFetch(options.networkMode) ? "fetching" : "paused", ...data === void 0 && { error: null, status: "pending" } }; } function getDefaultState(options) { const data = typeof options.initialData === "function" ? options.initialData() : options.initialData; const hasData = data !== void 0; const initialDataUpdatedAt = hasData ? typeof options.initialDataUpdatedAt === "function" ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0; return { data, dataUpdateCount: 0, dataUpdatedAt: hasData ? initialDataUpdatedAt ?? Date.now() : 0, error: null, errorUpdateCount: 0, errorUpdatedAt: 0, fetchFailureCount: 0, fetchFailureReason: null, fetchMeta: null, isInvalidated: false, status: hasData ? "success" : "pending", fetchStatus: "idle" }; } // ../../../node_modules/@tanstack/query-core/build/modern/queryCache.js var QueryCache = class extends Subscribable { constructor(config = {}) { super(); this.config = config; this.#queries = /* @__PURE__ */ new Map(); } #queries; build(client, options, state) { const queryKey = options.queryKey; const queryHash = options.queryHash ?? hashQueryKeyByOptions(queryKey, options); let query = this.get(queryHash); if (!query) { query = new Query({ client, queryKey, queryHash, options: client.defaultQueryOptions(options), state, defaultOptions: client.getQueryDefaults(queryKey) }); this.add(query); } return query; } add(query) { if (!this.#queries.has(query.queryHash)) { this.#queries.set(query.queryHash, query); this.notify({ type: "added", query }); } } remove(query) { const queryInMap = this.#queries.get(query.queryHash); if (queryInMap) { query.destroy(); if (queryInMap === query) { this.#queries.delete(query.queryHash); } this.notify({ type: "removed", query }); } } clear() { notifyManager.batch(() => { this.getAll().forEach((query) => { this.remove(query); }); }); } get(queryHash) { return this.#queries.get(queryHash); } getAll() { return [...this.#queries.values()]; } find(filters) { const defaultedFilters = { exact: true, ...filters }; return this.getAll().find( (query) => matchQuery(defaultedFilters, query) ); } findAll(filters = {}) { const queries = this.getAll(); return Object.keys(filters).length > 0 ? queries.filter((query) => matchQuery(filters, query)) : queries; } notify(event) { notifyManager.batch(() => { this.listeners.forEach((listener) => { listener(event); }); }); } onFocus() { notifyManager.batch(() => { this.getAll().forEach((query) => { query.onFocus(); }); }); } onOnline() { notifyManager.batch(() => { this.getAll().forEach((query) => { query.onOnline(); }); }); } }; // ../../../node_modules/@tanstack/query-core/build/modern/queryClient.js init_injected_globals(); // ../../../node_modules/@tanstack/query-core/build/modern/mutationCache.js init_injected_globals(); // ../../../node_modules/@tanstack/query-core/build/modern/mutation.js init_injected_globals(); var Mutation = class extends Removable { #observers; #mutationCache; #retryer; constructor(config) { super(); this.mutationId = config.mutationId; this.#mutationCache = config.mutationCache; this.#observers = []; this.state = config.state || getDefaultState2(); this.setOptions(config.options); this.scheduleGc(); } setOptions(options) { this.options = options; this.updateGcTime(this.options.gcTime); } get meta() { return this.options.meta; } addObserver(observer) { if (!this.#observers.includes(observer)) { this.#observers.push(observer); this.clearGcTimeout(); this.#mutationCache.notify({ type: "observerAdded", mutation: this, observer }); } } removeObserver(observer) { this.#observers = this.#observers.filter((x) => x !== observer); this.scheduleGc(); this.#mutationCache.notify({ type: "observerRemoved", mutation: this, observer }); } optionalRemove() { if (!this.#observers.length) { if (this.state.status === "pending") { this.scheduleGc(); } else { this.#mutationCache.remove(this); } } } continue() { return this.#retryer?.continue() ?? // continuing a mutation assumes that variables are set, mutation must have been dehydrated before this.execute(this.state.variables); } async execute(variables) { const onContinue = () => { this.#dispatch({ type: "continue" }); }; this.#retryer = createRetryer({ fn: () => { if (!this.options.mutationFn) { return Promise.reject(new Error("No mutationFn found")); } return this.options.mutationFn(variables); }, onFail: (failureCount, error) => { this.#dispatch({ type: "failed", failureCount, error }); }, onPause: () => { this.#dispatch({ type: "pause" }); }, onContinue, retry: this.options.retry ?? 0, retryDelay: this.options.retryDelay, networkMode: this.options.networkMode, canRun: () => this.#mutationCache.canRun(this) }); const restored = this.state.status === "pending"; const isPaused = !this.#retryer.canStart(); try { if (restored) { onContinue(); } else { this.#dispatch({ type: "pending", variables, isPaused }); await this.#mutationCache.config.onMutate?.( variables, this ); const context = await this.options.onMutate?.(variables); if (context !== this.state.context) { this.#dispatch({ type: "pending", context, variables, isPaused }); } } const data = await this.#retryer.start(); await this.#mutationCache.config.onSuccess?.( data, variables, this.state.context, this ); await this.options.onSuccess?.(data, variables, this.state.context); await this.#mutationCache.config.onSettled?.( data, null, this.state.variables, this.state.context, this ); await this.options.onSettled?.(data, null, variables, this.state.context); this.#dispatch({ type: "success", data }); return data; } catch (error) { try { await this.#mutationCache.config.onError?.( error, variables, this.state.context, this ); await this.options.onError?.( error, variables, this.state.context ); await this.#mutationCache.config.onSettled?.( void 0, error, this.state.variables, this.state.context, this ); await this.options.onSettled?.( void 0, error, variables, this.state.context ); throw error; } finally { this.#dispatch({ type: "error", error }); } } finally { this.#mutationCache.runNext(this); } } #dispatch(action) { const reducer = (state) => { switch (action.type) { case "failed": return { ...state, failureCount: action.failureCount, failureReason: action.error }; case "pause": return { ...state, isPaused: true }; case "continue": return { ...state, isPaused: false }; case "pending": return { ...state, context: action.context, data: void 0, failureCount: 0, failureReason: null, error: null, isPaused: action.isPaused, status: "pending", variables: action.variables, submittedAt: Date.now() }; case "success": return { ...state, data: action.data, failureCount: 0, failureReason: null, error: null, status: "success", isPaused: false }; case "error": return { ...state, data: void 0, error: action.error, failureCount: state.failureCount + 1, failureReason: action.error, isPaused: false, status: "error" }; } }; this.state = reducer(this.state); notifyManager.batch(() => { this.#observers.forEach((observer) => { observer.onMutationUpdate(action); }); this.#mutationCache.notify({ mutation: this, type: "updated", action }); }); } }; function getDefaultState2() { return { context: void 0, data: void 0, error: null, failureCount: 0, failureReason: null, isPaused: false, status: "idle", variables: void 0, submittedAt: 0 }; } // ../../../node_modules/@tanstack/query-core/build/modern/mutationCache.js var MutationCache = class extends Subscribable { constructor(config = {}) { super(); this.config = config; this.#mutations = /* @__PURE__ */ new Set(); this.#scopes = /* @__PURE__ */ new Map(); this.#mutationId = 0; } #mutations; #scopes; #mutationId; build(client, options, state) { const mutation = new Mutation({ mutationCache: this, mutationId: ++this.#mutationId, options: client.defaultMutationOptions(options), state }); this.add(mutation); return mutation; } add(mutation) { this.#mutations.add(mutation); const scope = scopeFor(mutation); if (typeof scope === "string") { const scopedMutations = this.#scopes.get(scope); if (scopedMutations) { scopedMutations.push(mutation); } else { this.#scopes.set(scope, [mutation]); } } this.notify({ type: "added", mutation }); } remove(mutation) { if (this.#mutations.delete(mutation)) { const scope = scopeFor(mutation); if (typeof scope === "string") { const scopedMutations = this.#scopes.get(scope); if (scopedMutations) { if (scopedMutations.length > 1) { const index = scopedMutations.indexOf(mutation); if (index !== -1) { scopedMutations.splice(index, 1); } } else if (scopedMutations[0] === mutation) { this.#scopes.delete(scope); } } } } this.notify({ type: "removed", mutation }); } canRun(mutation) { const scope = scopeFor(mutation); if (typeof scope === "string") { const mutationsWithSameScope = this.#scopes.get(scope); const firstPendingMutation = mutationsWithSameScope?.find( (m) => m.state.status === "pending" ); return !firstPendingMutation || firstPendingMutation === mutation; } else { return true; } } runNext(mutation) { const scope = scopeFor(mutation); if (typeof scope === "string") { const foundMutation = this.#scopes.get(scope)?.find((m) => m !== mutation && m.state.isPaused); return foundMutation?.continue() ?? Promise.resolve(); } else { return Promise.resolve(); } } clear() { notifyManager.batch(() => { this.#mutations.forEach((mutation) => { this.notify({ type: "removed", mutation }); }); this.#mutations.clear(); this.#scopes.clear(); }); } getAll() { return Array.from(this.#mutations); } find(filters) { const defaultedFilters = { exact: true, ...filters }; return this.getAll().find( (mutation) => matchMutation(defaultedFilters, mutation) ); } findAll(filters = {}) { return this.getAll().filter((mutation) => matchMutation(filters, mutation)); } notify(event) { notifyManager.batch(() => { this.listeners.forEach((listener) => { listener(event); }); }); } resumePausedMutations() { const pausedMutations = this.getAll().filter((x) => x.state.isPaused); return notifyManager.batch( () => Promise.all( pausedMutations.map((mutation) => mutation.continue().catch(noop)) ) ); } }; function scopeFor(mutation) { return mutation.options.scope?.id; } // ../../../node_modules/@tanstack/query-core/build/modern/infiniteQueryBehavior.js init_injected_globals(); function infiniteQueryBehavior(pages) { return { onFetch: (context, query) => { const options = context.options; const direction = context.fetchOptions?.meta?.fetchMore?.direction; const oldPages = context.state.data?.pages || []; const oldPageParams = context.state.data?.pageParams || []; let result = { pages: [], pageParams: [] }; let currentPage = 0; const fetchFn = async () => { let cancelled = false; const addSignalProperty = (object) => { Object.defineProperty(object, "signal", { enumerable: true, get: () => { if (context.signal.aborted) { cancelled = true; } else { context.signal.addEventListener("abort", () => { cancelled = true; }); } return context.signal; } }); }; const queryFn = ensureQueryFn(context.options, context.fetchOptions); const fetchPage = async (data, param, previous) => { if (cancelled) { return Promise.reject(); } if (param == null && data.pages.length) { return Promise.resolve(data); } const queryFnContext = { client: context.client, queryKey: context.queryKey, pageParam: param, direction: previous ? "backward" : "forward", meta: context.options.meta }; addSignalProperty(queryFnContext); const page = await queryFn( queryFnContext ); const { maxPages } = context.options; const addTo = previous ? addToStart : addToEnd; return { pages: addTo(data.pages, page, maxPages), pageParams: addTo(data.pageParams, param, maxPages) }; }; if (direction && oldPages.length) { const previous = direction === "backward"; const pageParamFn = previous ? getPreviousPageParam : getNextPageParam; const oldData = { pages: oldPages, pageParams: oldPageParams }; const param = pageParamFn(options, oldData); result = await fetchPage(oldData, param, previous); } else { const remainingPages = pages ?? oldPages.length; do { const param = currentPage === 0 ? oldPageParams[0] ?? options.initialPageParam : getNextPageParam(options, result); if (currentPage > 0 && param == null) { break; } result = await fetchPage(result, param); currentPage++; } while (currentPage < remainingPages); } return result; }; if (context.options.persister) { context.fetchFn = () => { return context.options.persister?.( fetchFn, { client: context.client, queryKey: context.queryKey, meta: context.options.meta, signal: context.signal }, query ); }; } else { context.fetchFn = fetchFn; } } }; } function getNextPageParam(options, { pages, pageParams }) { const lastIndex = pages.length - 1; return pages.length > 0 ? options.getNextPageParam( pages[lastIndex], pages, pageParams[lastIndex], pageParams ) : void 0; } function getPreviousPageParam(options, { pages, pageParams }) { return pages.length > 0 ? options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams) : void 0; } // ../../../node_modules/@tanstack/query-core/build/modern/queryClient.js var QueryClient = class { #queryCache; #mutationCache; #defaultOptions; #queryDefaults; #mutationDefaults; #mountCount; #unsubscribeFocus; #unsubscribeOnline; constructor(config = {}) { this.#queryCache = config.queryCache || new QueryCache(); this.#mutationCache = config.mutationCache || new MutationCache(); this.#defaultOptions = config.defaultOptions || {}; this.#queryDefaults = /* @__PURE__ */ new Map(); this.#mutationDefaults = /* @__PURE__ */ new Map(); this.#mountCount = 0; } mount() { this.#mountCount++; if (this.#mountCount !== 1) return; this.#unsubscribeFocus = focusManager.subscribe(async (focused) => { if (focused) { await this.resumePausedMutations(); this.#queryCache.onFocus(); } }); this.#unsubscribeOnline = onlineManager.subscribe(async (online) => { if (online) { await this.resumePausedMutations(); this.#queryCache.onOnline(); } }); } unmount() { this.#mountCount--; if (this.#mountCount !== 0) return; this.#unsubscribeFocus?.(); this.#unsubscribeFocus = void 0; this.#unsubscribeOnline?.(); this.#unsubscribeOnline = void 0; } isFetching(filters) { return this.#queryCache.findAll({ ...filters, fetchStatus: "fetching" }).length; } isMutating(filters) { return this.#mutationCache.findAll({ ...filters, status: "pending" }).length; } /** * Imperative (non-reactive) way to retrieve data for a QueryKey. * Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates. * * Hint: Do not use this function inside a component, because it won't receive updates. * Use `useQuery` to create a `QueryObserver` that subscribes to changes. */ getQueryData(queryKey) { const options = this.defaultQueryOptions({ queryKey }); return this.#queryCache.get(options.queryHash)?.state.data; } ensureQueryData(options) { const defaultedOptions = this.defaultQueryOptions(options); const query = this.#queryCache.build(this, defaultedOptions); const cachedData = query.state.data; if (cachedData === void 0) { return this.fetchQuery(options); } if (options.revalidateIfStale && query.isStaleByTime(resolveStaleTime(defaultedOptions.staleTime, query))) { void this.prefetchQuery(defaultedOptions); } return Promise.resolve(cachedData); } getQueriesData(filters) { return this.#queryCache.findAll(filters).map(({ queryKey, state }) => { const data = state.data; return [queryKey, data]; }); } setQueryData(queryKey, updater, options) { const defaultedOptions = this.defaultQueryOptions({ queryKey }); const query = this.#queryCache.get( defaultedOptions.queryHash ); const prevData = query?.state.data; const data = functionalUpdate(updater, prevData); if (data === void 0) { return void 0; } return this.#queryCache.build(this, defaultedOptions).setData(data, { ...options, manual: true }); } setQueriesData(filters, updater, options) { return notifyManager.batch( () => this.#queryCache.findAll(filters).map(({ queryKey }) => [ queryKey, this.setQueryData(queryKey, updater, options) ]) ); } getQueryState(queryKey) { const options = this.defaultQueryOptions({ queryKey }); return this.#queryCache.get( options.queryHash )?.state; } removeQueries(filters) { const queryCache = this.#queryCache; notifyManager.batch(() => { queryCache.findAll(filters).forEach((query) => { queryCache.remove(query); }); }); } resetQueries(filters, options) { const queryCache = this.#queryCache; return notifyManager.batch(() => { queryCache.findAll(filters).forEach((query) => { query.reset(); }); return this.refetchQueries( { type: "active", ...filters }, options ); }); } cancelQueries(filters, cancelOptions = {}) { const defaultedCancelOptions = { revert: true, ...cancelOptions }; const promises = notifyManager.batch( () => this.#queryCache.findAll(filters).map((query) => query.cancel(defaultedCancelOptions)) ); return Promise.all(promises).then(noop).catch(noop); } invalidateQueries(filters, options = {}) { return notifyManager.batch(() => { this.#queryCache.findAll(filters).forEach((query) => { query.invalidate(); }); if (filters?.refetchType === "none") { return Promise.resolve(); } return this.refetchQueries( { ...filters, type: filters?.refetchType ?? filters?.type ?? "active" }, options ); }); } refetchQueries(filters, options = {}) { const fetchOptions = { ...options, cancelRefetch: options.cancelRefetch ?? true }; const promises = notifyManager.batch( () => this.#queryCache.findAll(filters).filter((query) => !query.isDisabled()).map((query) => { let promise = query.fetch(void 0, fetchOptions); if (!fetchOptions.throwOnError) { promise = promise.catch(noop); } return query.state.fetchStatus === "paused" ? Promise.resolve() : promise; }) ); return Promise.all(promises).then(noop); } fetchQuery(options) { const defaultedOptions = this.defaultQueryOptions(options); if (defaultedOptions.retry === void 0) { defaultedOptions.retry = false; } const query = this.#queryCache.build(this, defaultedOptions); return query.isStaleByTime( resolveStaleTime(defaultedOptions.staleTime, query) ) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data); } prefetchQuery(options) { return this.fetchQuery(options).then(noop).catch(noop); } fetchInfiniteQuery(options) { options.behavior = infiniteQueryBehavior(options.pages); return this.fetchQuery(options); } prefetchInfiniteQuery(options) { return this.fetchInfiniteQuery(options).then(noop).catch(noop); } ensureInfiniteQueryData(options) { options.behavior = infiniteQueryBehavior(options.pages); return this.ensureQueryData(options); } resumePausedMutations() { if (onlineManager.isOnline()) { return this.#mutationCache.resumePausedMutations(); } return Promise.resolve(); } getQueryCache() { return this.#queryCache; } getMutationCache() { return this.#mutationCache; } getDefaultOptions() { return this.#defaultOptions; } setDefaultOptions(options) { this.#defaultOptions = options; } setQueryDefaults(queryKey, options) { this.#queryDefaults.set(hashKey(queryKey), { queryKey, defaultOptions: options }); } getQueryDefaults(queryKey) { const defaults = [...this.#queryDefaults.values()]; const result = {}; defaults.forEach((queryDefault) => { if (partialMatchKey(queryKey, queryDefault.queryKey)) { Object.assign(result, queryDefault.defaultOptions); } }); return result; } setMutationDefaults(mutationKey, options) { this.#mutationDefaults.set(hashKey(mutationKey), { mutationKey, defaultOptions: options }); } getMutationDefaults(mutationKey) { const defaults = [...this.#mutationDefaults.values()]; const result = {}; defaults.forEach((queryDefault) => { if (partialMatchKey(mutationKey, queryDefault.mutationKey)) { Object.assign(result, queryDefault.defaultOptions); } }); return result; } defaultQueryOptions(options) { if (options._defaulted) { return options; } const defaultedOptions = { ...this.#defaultOptions.queries, ...this.getQueryDefaults(options.queryKey), ...options, _defaulted: true }; if (!defaultedOptions.queryHash) { defaultedOptions.queryHash = hashQueryKeyByOptions( defaultedOptions.queryKey, defaultedOptions ); } if (defaultedOptions.refetchOnReconnect === void 0) { defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== "always"; } if (defaultedOptions.throwOnError === void 0) { defaultedOptions.throwOnError = !!defaultedOptions.suspense; } if (!defaultedOptions.networkMode && defaultedOptions.persister) { defaultedOptions.networkMode = "offlineFirst"; } if (defaultedOptions.queryFn === skipToken) { defaultedOptions.enabled = false; } return defaultedOptions; } defaultMutationOptions(options) { if (options?._defaulted) { return options; } return { ...this.#defaultOptions.mutations, ...options?.mutationKey && this.getMutationDefaults(options.mutationKey), ...options, _defaulted: true }; } clear() { this.#queryCache.clear(); this.#mutationCache.clear(); } }; // ../../../node_modules/@tanstack/query-core/build/modern/queryObserver.js init_injected_globals(); var QueryObserver = class extends Subscribable { constructor(client, options) { super(); this.options = options; this.#client = client; this.#selectError = null; this.#currentThenable = pendingThenable(); if (!this.options.experimental_prefetchInRender) { this.#currentThenable.reject( new Error("experimental_prefetchInRender feature flag is not enabled") ); } this.bindMethods(); this.setOptions(options); } #client; #currentQuery = void 0; #currentQueryInitialState = void 0; #currentResult = void 0; #currentResultState; #currentResultOptions; #currentThenable; #selectError; #selectFn; #selectResult; // This property keeps track of the last query with defined data. // It will be used to pass the previous data and query to the placeholder function between renders. #lastQueryWithDefinedData; #staleTimeoutId; #refetchIntervalId; #currentRefetchInterval; #trackedProps = /* @__PURE__ */ new Set(); bindMethods() { this.refetch = this.refetch.bind(this); } onSubscribe() { if (this.listeners.size === 1) { this.#currentQuery.addObserver(this); if (shouldFetchOnMount(this.#currentQuery, this.options)) { this.#executeFetch(); } else { this.updateResult(); } this.#updateTimers(); } } onUnsubscribe() { if (!this.hasListeners()) { this.destroy(); } } shouldFetchOnReconnect() { return shouldFetchOn( this.#currentQuery, this.options, this.options.refetchOnReconnect ); } shouldFetchOnWindowFocus() { return shouldFetchOn( this.#currentQuery, this.options, this.options.refetchOnWindowFocus ); } destroy() { this.listeners = /* @__PURE__ */ new Set(); this.#clearStaleTimeout(); this.#clearRefetchInterval(); this.#currentQuery.removeObserver(this); } setOptions(options) { const prevOptions = this.options; const prevQuery = this.#currentQuery; this.options = this.#client.defaultQueryOptions(options); if (this.options.enabled !== void 0 && typeof this.options.enabled !== "boolean" && typeof this.options.enabled !== "function" && typeof resolveEnabled(this.options.enabled, this.#currentQuery) !== "boolean") { throw new Error( "Expected enabled to be a boolean or a callback that returns a boolean" ); } this.#updateQuery(); this.#currentQuery.setOptions(this.options); if (prevOptions._defaulted && !shallowEqualObjects(this.options, prevOptions)) { this.#client.getQueryCache().notify({ type: "observerOptionsUpdated", query: this.#currentQuery, observer: this }); } const mounted = this.hasListeners(); if (mounted && shouldFetchOptionally( this.#currentQuery, prevQuery, this.options, prevOptions )) { this.#executeFetch(); } this.updateResult(); if (mounted && (this.#currentQuery !== prevQuery || resolveEnabled(this.options.enabled, this.#currentQuery) !== resolveEnabled(prevOptions.enabled, this.#currentQuery) || resolveStaleTime(this.options.staleTime, this.#currentQuery) !== resolveStaleTime(prevOptions.staleTime, this.#currentQuery))) { this.#updateStaleTimeout(); } const nextRefetchInterval = this.#computeRefetchInterval(); if (mounted && (this.#currentQuery !== prevQuery || resolveEnabled(this.options.enabled, this.#currentQuery) !== resolveEnabled(prevOptions.enabled, this.#currentQuery) || nextRefetchInterval !== this.#currentRefetchInterval)) { this.#updateRefetchInterval(nextRefetchInterval); } } getOptimisticResult(options) { const query = this.#client.getQueryCache().build(this.#client, options); const result = this.createResult(query, options); if (shouldAssignObserverCurrentProperties(this, result)) { this.#currentResult = result; this.#currentResultOptions = this.options; this.#currentResultState = this.#currentQuery.state; } return result; } getCurrentResult() { return this.#currentResult; } trackResult(result, onPropTracked) { const trackedResult = {}; Object.keys(result).forEach((key) => { Object.defineProperty(trackedResult, key, { configurable: false, enumerable: true, get: () => { this.trackProp(key); onPropTracked?.(key); return result[key]; } }); }); return trackedResult; } trackProp(key) { this.#trackedProps.add(key); } getCurrentQuery() { return this.#currentQuery; } refetch({ ...options } = {}) { return this.fetch({ ...options }); } fetchOptimistic(options) { const defaultedOptions = this.#client.defaultQueryOptions(options); const query = this.#client.getQueryCache().build(this.#client, defaultedOptions); return query.fetch().then(() => this.createResult(query, defaultedOptions)); } fetch(fetchOptions) { return this.#executeFetch({ ...fetchOptions, cancelRefetch: fetchOptions.cancelRefetch ?? true }).then(() => { this.updateResult(); return this.#currentResult; }); } #executeFetch(fetchOptions) { this.#updateQuery(); let promise = this.#currentQuery.fetch( this.options, fetchOptions ); if (!fetchOptions?.throwOnError) { promise = promise.catch(noop); } return promise; } #updateStaleTimeout() { this.#clearStaleTimeout(); const staleTime = resolveStaleTime( this.options.staleTime, this.#currentQuery ); if (isServer || this.#currentResult.isStale || !isValidTimeout(staleTime)) { return; } const time = timeUntilStale(this.#currentResult.dataUpdatedAt, staleTime); const timeout = time + 1; this.#staleTimeoutId = setTimeout(() => { if (!this.#currentResult.isStale) { this.updateResult(); } }, timeout); } #computeRefetchInterval() { return (typeof this.options.refetchInterval === "function" ? this.options.refetchInterval(this.#currentQuery) : this.options.refetchInterval) ?? false; } #updateRefetchInterval(nextInterval) { this.#clearRefetchInterval(); this.#currentRefetchInterval = nextInterval; if (isServer || resolveEnabled(this.options.enabled, this.#currentQuery) === false || !isValidTimeout(this.#currentRefetchInterval) || this.#currentRefetchInterval === 0) { return; } this.#refetchIntervalId = setInterval(() => { if (this.options.refetchIntervalInBackground || focusManager.isFocused()) { this.#executeFetch(); } }, this.#currentRefetchInterval); } #updateTimers() { this.#updateStaleTimeout(); this.#updateRefetchInterval(this.#computeRefetchInterval()); } #clearStaleTimeout() { if (this.#staleTimeoutId) { clearTimeout(this.#staleTimeoutId); this.#staleTimeoutId = void 0; } } #clearRefetchInterval() { if (this.#refetchIntervalId) { clearInterval(this.#refetchIntervalId); this.#refetchIntervalId = void 0; } } createResult(query, options) { const prevQuery = this.#currentQuery; const prevOptions = this.options; const prevResult = this.#currentResult; const prevResultState = this.#currentResultState; const prevResultOptions = this.#currentResultOptions; const queryChange = query !== prevQuery; const queryInitialState = queryChange ? query.state : this.#currentQueryInitialState; const { state } = query; let newState = { ...state }; let isPlaceholderData = false; let data; if (options._optimisticResults) { const mounted = this.hasListeners(); const fetchOnMount = !mounted && shouldFetchOnMount(query, options); const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions); if (fetchOnMount || fetchOptionally) { newState = { ...newState, ...fetchState(state.data, query.options) }; } if (options._optimisticResults === "isRestoring") { newState.fetchStatus = "idle"; } } let { error, errorUpdatedAt, status } = newState; data = newState.data; let skipSelect = false; if (options.placeholderData !== void 0 && data === void 0 && status === "pending") { let placeholderData; if (prevResult?.isPlaceholderData && options.placeholderData === prevResultOptions?.placeholderData) { placeholderData = prevResult.data; skipSelect = true; } else { placeholderData = typeof options.placeholderData === "function" ? options.placeholderData( this.#lastQueryWithDefinedData?.state.data, this.#lastQueryWithDefinedData ) : options.placeholderData; } if (placeholderData !== void 0) { status = "success"; data = replaceData( prevResult?.data, placeholderData, options ); isPlaceholderData = true; } } if (options.select && data !== void 0 && !skipSelect) { if (prevResult && data === prevResultState?.data && options.select === this.#selectFn) { data = this.#selectResult; } else { try { this.#selectFn = options.select; data = options.select(data); data = replaceData(prevResult?.data, data, options); this.#selectResult = data; this.#selectError = null; } catch (selectError) { this.#selectError = selectError; } } } if (this.#selectError) { error = this.#selectError; data = this.#selectResult; errorUpdatedAt = Date.now(); status = "error"; } const isFetching = newState.fetchStatus === "fetching"; const isPending = status === "pending"; const isError = status === "error"; const isLoading = isPending && isFetching; const hasData = data !== void 0; const result = { status, fetchStatus: newState.fetchStatus, isPending, isSuccess: status === "success", isError, isInitialLoading: isLoading, isLoading, data, dataUpdatedAt: newState.dataUpdatedAt, error, errorUpdatedAt, failureCount: newState.fetchFailureCount, failureReason: newState.fetchFailureReason, errorUpdateCount: newState.errorUpdateCount, isFetched: newState.dataUpdateCount > 0 || newState.errorUpdateCount > 0, isFetchedAfterMount: newState.dataUpdateCount > queryInitialState.dataUpdateCount || newState.errorUpdateCount > queryInitialState.errorUpdateCount, isFetching, isRefetching: isFetching && !isPending, isLoadingError: isError && !hasData, isPaused: newState.fetchStatus === "paused", isPlaceholderData, isRefetchError: isError && hasData, isStale: isStale(query, options), refetch: this.refetch, promise: this.#currentThenable }; const nextResult = result; if (this.options.experimental_prefetchInRender) { const finalizeThenableIfPossible = (thenable) => { if (nextResult.status === "error") { thenable.reject(nextResult.error); } else if (nextResult.data !== void 0) { thenable.resolve(nextResult.data); } }; const recreateThenable = () => { const pending = this.#currentThenable = nextResult.promise = pendingThenable(); finalizeThenableIfPossible(pending); }; const prevThenable = this.#currentThenable; switch (prevThenable.status) { case "pending": if (query.queryHash === prevQuery.queryHash) { finalizeThenableIfPossible(prevThenable); } break; case "fulfilled": if (nextResult.status === "error" || nextResult.data !== prevThenable.value) { recreateThenable(); } break; case "rejected": if (nextResult.status !== "error" || nextResult.error !== prevThenable.reason) { recreateThenable(); } break; } } return nextResult; } updateResult() { const prevResult = this.#currentResult; const nextResult = this.createResult(this.#currentQuery, this.options); this.#currentResultState = this.#currentQuery.state; this.#currentResultOptions = this.options; if (this.#currentResultState.data !== void 0) { this.#lastQueryWithDefinedData = this.#currentQuery; } if (shallowEqualObjects(nextResult, prevResult)) { return; } this.#currentResult = nextResult; const shouldNotifyListeners = () => { if (!prevResult) { return true; } const { notifyOnChangeProps } = this.options; const notifyOnChangePropsValue = typeof notifyOnChangeProps === "function" ? notifyOnChangeProps() : notifyOnChangeProps; if (notifyOnChangePropsValue === "all" || !notifyOnChangePropsValue && !this.#trackedProps.size) { return true; } const includedProps = new Set( notifyOnChangePropsValue ?? this.#trackedProps ); if (this.options.throwOnError) { includedProps.add("error"); } return Object.keys(this.#currentResult).some((key) => { const typedKey = key; const changed = this.#currentResult[typedKey] !== prevResult[typedKey]; return changed && includedProps.has(typedKey); }); }; this.#notify({ listeners: shouldNotifyListeners() }); } #updateQuery() { const query = this.#client.getQueryCache().build(this.#client, this.options); if (query === this.#currentQuery) { return; } const prevQuery = this.#currentQuery; this.#currentQuery = query; this.#currentQueryInitialState = query.state; if (this.hasListeners()) { prevQuery?.removeObserver(this); query.addObserver(this); } } onQueryUpdate() { this.updateResult(); if (this.hasListeners()) { this.#updateTimers(); } } #notify(notifyOptions) { notifyManager.batch(() => { if (notifyOptions.listeners) { this.listeners.forEach((listener) => { listener(this.#currentResult); }); } this.#client.getQueryCache().notify({ query: this.#currentQuery, type: "observerResultsUpdated" }); }); } }; function shouldLoadOnMount(query, options) { return resolveEnabled(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && options.retryOnMount === false); } function shouldFetchOnMount(query, options) { return shouldLoadOnMount(query, options) || query.state.data !== void 0 && shouldFetchOn(query, options, options.refetchOnMount); } function shouldFetchOn(query, options, field) { if (resolveEnabled(options.enabled, query) !== false) { const value = typeof field === "function" ? field(query) : field; return value === "always" || value !== false && isStale(query, options); } return false; } function shouldFetchOptionally(query, prevQuery, options, prevOptions) { return (query !== prevQuery || resolveEnabled(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options); } function isStale(query, options) { return resolveEnabled(options.enabled, query) !== false && query.isStaleByTime(resolveStaleTime(options.staleTime, query)); } function shouldAssignObserverCurrentProperties(observer, optimisticResult) { if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) { return true; } return false; } // ../../../node_modules/@tanstack/query-core/build/modern/mutationObserver.js init_injected_globals(); var MutationObserver = class extends Subscribable { #client; #currentResult = void 0; #currentMutation; #mutateOptions; constructor(client, options) { super(); this.#client = client; this.setOptions(options); this.bindMethods(); this.#updateResult(); } bindMethods() { this.mutate = this.mutate.bind(this); this.reset = this.reset.bind(this); } setOptions(options) { const prevOptions = this.options; this.options = this.#client.defaultMutationOptions(options); if (!shallowEqualObjects(this.options, prevOptions)) { this.#client.getMutationCache().notify({ type: "observerOptionsUpdated", mutation: this.#currentMutation, observer: this }); } if (prevOptions?.mutationKey && this.options.mutationKey && hashKey(prevOptions.mutationKey) !== hashKey(this.options.mutationKey)) { this.reset(); } else if (this.#currentMutation?.state.status === "pending") { this.#currentMutation.setOptions(this.options); } } onUnsubscribe() { if (!this.hasListeners()) { this.#currentMutation?.removeObserver(this); } } onMutationUpdate(action) { this.#updateResult(); this.#notify(action); } getCurrentResult() { return this.#currentResult; } reset() { this.#currentMutation?.removeObserver(this); this.#currentMutation = void 0; this.#updateResult(); this.#notify(); } mutate(variables, options) { this.#mutateOptions = options; this.#currentMutation?.removeObserver(this); this.#currentMutation = this.#client.getMutationCache().build(this.#client, this.options); this.#currentMutation.addObserver(this); return this.#currentMutation.execute(variables); } #updateResult() { const state = this.#currentMutation?.state ?? getDefaultState2(); this.#currentResult = { ...state, isPending: state.status === "pending", isSuccess: state.status === "success", isError: state.status === "error", isIdle: state.status === "idle", mutate: this.mutate, reset: this.reset }; } #notify(action) { notifyManager.batch(() => { if (this.#mutateOptions && this.hasListeners()) { const variables = this.#currentResult.variables; const context = this.#currentResult.context; if (action?.type === "success") { this.#mutateOptions.onSuccess?.(action.data, variables, context); this.#mutateOptions.onSettled?.(action.data, null, variables, context); } else if (action?.type === "error") { this.#mutateOptions.onError?.(action.error, variables, context); this.#mutateOptions.onSettled?.( void 0, action.error, variables, context ); } } this.listeners.forEach((listener) => { listener(this.#currentResult); }); }); } }; // ../../../node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js init_injected_globals(); var React2 = __toESM(require_react(), 1); var import_jsx_runtime = __toESM(require_jsx_runtime(), 1); var QueryClientContext = React2.createContext( void 0 ); var useQueryClient = (queryClient2) => { const client = React2.useContext(QueryClientContext); if (queryClient2) { return queryClient2; } if (!client) { throw new Error("No QueryClient set, use QueryClientProvider to set one"); } return client; }; var QueryClientProvider = ({ client, children }) => { React2.useEffect(() => { client.mount(); return () => { client.unmount(); }; }, [client]); return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(QueryClientContext.Provider, { value: client, children }); }; // ../../../node_modules/@tanstack/react-query/build/modern/isRestoring.js init_injected_globals(); var React3 = __toESM(require_react(), 1); var IsRestoringContext = React3.createContext(false); var useIsRestoring = () => React3.useContext(IsRestoringContext); var IsRestoringProvider = IsRestoringContext.Provider; // ../../../node_modules/@tanstack/react-query/build/modern/QueryErrorResetBoundary.js init_injected_globals(); var React4 = __toESM(require_react(), 1); var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1); function createValue() { let isReset = false; return { clearReset: () => { isReset = false; }, reset: () => { isReset = true; }, isReset: () => { return isReset; } }; } var QueryErrorResetBoundaryContext = React4.createContext(createValue()); var useQueryErrorResetBoundary = () => React4.useContext(QueryErrorResetBoundaryContext); // ../../../node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.js init_injected_globals(); var React5 = __toESM(require_react(), 1); // ../../../node_modules/@tanstack/react-query/build/modern/utils.js init_injected_globals(); function shouldThrowError(throwError, params) { if (typeof throwError === "function") { return throwError(...params); } return !!throwError; } function noop2() { } // ../../../node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.js var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => { if (options.suspense || options.throwOnError || options.experimental_prefetchInRender) { if (!errorResetBoundary.isReset()) { options.retryOnMount = false; } } }; var useClearResetErrorBoundary = (errorResetBoundary) => { React5.useEffect(() => { errorResetBoundary.clearReset(); }, [errorResetBoundary]); }; var getHasError = ({ result, errorResetBoundary, throwOnError, query, suspense }) => { return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 || shouldThrowError(throwOnError, [result.error, query])); }; // ../../../node_modules/@tanstack/react-query/build/modern/suspense.js init_injected_globals(); var ensureSuspenseTimers = (defaultedOptions) => { const originalStaleTime = defaultedOptions.staleTime; if (defaultedOptions.suspense) { defaultedOptions.staleTime = typeof originalStaleTime === "function" ? (...args) => Math.max(originalStaleTime(...args), 1e3) : Math.max(originalStaleTime ?? 1e3, 1e3); if (typeof defaultedOptions.gcTime === "number") { defaultedOptions.gcTime = Math.max(defaultedOptions.gcTime, 1e3); } } }; var willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring; var shouldSuspend = (defaultedOptions, result) => defaultedOptions?.suspense && result.isPending; var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => { errorResetBoundary.clearReset(); }); // ../../../node_modules/@tanstack/react-query/build/modern/useQuery.js init_injected_globals(); // ../../../node_modules/@tanstack/react-query/build/modern/useBaseQuery.js init_injected_globals(); var React6 = __toESM(require_react(), 1); function useBaseQuery(options, Observer, queryClient2) { if (false) { if (typeof options !== "object" || Array.isArray(options)) { throw new Error( 'Bad argument type. Starting with v5, only the "Object" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object' ); } } const client = useQueryClient(queryClient2); const isRestoring = useIsRestoring(); const errorResetBoundary = useQueryErrorResetBoundary(); const defaultedOptions = client.defaultQueryOptions(options); client.getDefaultOptions().queries?._experimental_beforeQuery?.( defaultedOptions ); if (false) { if (!defaultedOptions.queryFn) { console.error( `[${defaultedOptions.queryHash}]: No queryFn was passed as an option, and no default queryFn was found. The queryFn parameter is only optional when using a default queryFn. More info here: https://tanstack.com/query/latest/docs/framework/react/guides/default-query-function` ); } } defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic"; ensureSuspenseTimers(defaultedOptions); ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary); useClearResetErrorBoundary(errorResetBoundary); const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash); const [observer] = React6.useState( () => new Observer( client, defaultedOptions ) ); const result = observer.getOptimisticResult(defaultedOptions); const shouldSubscribe = !isRestoring && options.subscribed !== false; React6.useSyncExternalStore( React6.useCallback( (onStoreChange) => { const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop2; observer.updateResult(); return unsubscribe; }, [observer, shouldSubscribe] ), () => observer.getCurrentResult(), () => observer.getCurrentResult() ); React6.useEffect(() => { observer.setOptions(defaultedOptions); }, [defaultedOptions, observer]); if (shouldSuspend(defaultedOptions, result)) { throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary); } if (getHasError({ result, errorResetBoundary, throwOnError: defaultedOptions.throwOnError, query: client.getQueryCache().get(defaultedOptions.queryHash), suspense: defaultedOptions.suspense })) { throw result.error; } ; client.getDefaultOptions().queries?._experimental_afterQuery?.( defaultedOptions, result ); if (defaultedOptions.experimental_prefetchInRender && !isServer && willFetch(result, isRestoring)) { const promise = isNewCacheEntry ? ( // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted fetchOptimistic(defaultedOptions, observer, errorResetBoundary) ) : ( // subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in client.getQueryCache().get(defaultedOptions.queryHash)?.promise ); promise?.catch(noop2).finally(() => { observer.updateResult(); }); } return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result; } // ../../../node_modules/@tanstack/react-query/build/modern/useQuery.js function useQuery(options, queryClient2) { return useBaseQuery(options, QueryObserver, queryClient2); } // ../../../node_modules/@tanstack/react-query/build/modern/useMutation.js init_injected_globals(); var React7 = __toESM(require_react(), 1); function useMutation(options, queryClient2) { const client = useQueryClient(queryClient2); const [observer] = React7.useState( () => new MutationObserver( client, options ) ); React7.useEffect(() => { observer.setOptions(options); }, [observer, options]); const result = React7.useSyncExternalStore( React7.useCallback( (onStoreChange) => observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer] ), () => observer.getCurrentResult(), () => observer.getCurrentResult() ); const mutate = React7.useCallback( (variables, mutateOptions) => { observer.mutate(variables, mutateOptions).catch(noop2); }, [observer] ); if (result.error && shouldThrowError(observer.options.throwOnError, [result.error])) { throw result.error; } return { ...result, mutate, mutateAsync: result.mutate }; } // virtual:/apps/web/src/utils/useUser.js var useUser = () => { const query = useQuery({ queryKey: ["auth", "token"], queryFn: async () => { const res = await fetch("/api/auth/token", { cache: "no-store" }); if (!res.ok) { if ([401, 403].includes(res.status)) return null; try { const text2 = await res.text(); console.error( "/api/auth/token failed:", res.status, res.statusText, text2 ); } catch (_) { } return null; } const json = await res.json(); return json?.user ?? null; }, // Don’t refetch on window focus to avoid noisy calls refetchOnWindowFocus: false, // Small stale time so quick navigations don’t spam the endpoint staleTime: 15e3 }); return { user: query.data, data: query.data, loading: query.isLoading, refetch: query.refetch }; }; var useUser_default = useUser; // virtual:/apps/web/src/hooks/useDashboardState.js init_injected_globals(); var import_react = __toESM(require_react()); function useDashboardState() { const [urlParams, setUrlParams] = (0, import_react.useState)(() => { if (typeof window === "undefined") return new URLSearchParams(); return new URLSearchParams(window.location.search); }); const [presets, setPresets] = (0, import_react.useState)({}); const [selectedPreset, setSelectedPreset] = (0, import_react.useState)(""); const [compact, setCompact] = (0, import_react.useState)(false); const [autoRefresh, setAutoRefresh] = (0, import_react.useState)(false); const [superCompact, setSuperCompact] = (0, import_react.useState)(false); const [wrapDesc, setWrapDesc] = (0, import_react.useState)(false); const [selectedIds, setSelectedIds] = (0, import_react.useState)(/* @__PURE__ */ new Set()); const [selectAllActive, setSelectAllActive] = (0, import_react.useState)(false); const [excludedIds, setExcludedIds] = (0, import_react.useState)(/* @__PURE__ */ new Set()); (0, import_react.useEffect)(() => { if (typeof window === "undefined") return; try { const saved = localStorage.getItem("dashboardViewPresets"); if (saved) setPresets(JSON.parse(saved) || {}); const savedDensity = localStorage.getItem("dashboardDensity"); if (savedDensity) setCompact(savedDensity === "compact"); const savedAuto = localStorage.getItem("dashboardAutoRefresh"); if (savedAuto) setAutoRefresh(savedAuto === "1"); const savedSuper = localStorage.getItem("dashboardSuperCompact"); if (savedSuper) setSuperCompact(savedSuper === "1"); const savedWrap = localStorage.getItem("dashboardWrapDesc"); if (savedWrap) setWrapDesc(savedWrap === "1"); const sel = localStorage.getItem("dashboardSelectedIds"); if (sel) setSelectedIds(new Set(JSON.parse(sel))); const sa = localStorage.getItem("dashboardSelectAllActive"); if (sa) setSelectAllActive(sa === "1"); const ex = localStorage.getItem("dashboardExcludedIds"); if (ex) setExcludedIds(new Set(JSON.parse(ex))); } catch (_) { } }, []); (0, import_react.useEffect)(() => { if (typeof window === "undefined") return; const hasUrl = window.location.search.length > 1; if (!hasUrl) { try { const saved = localStorage.getItem("dashboardTableState"); if (saved) { const obj = JSON.parse(saved); const params = new URLSearchParams(); if (obj.q) params.set("q", obj.q); if (obj.qField && obj.qField !== "all") params.set("qField", obj.qField); if (obj.createdFrom) params.set("createdFrom", obj.createdFrom); if (obj.createdTo) params.set("createdTo", obj.createdTo); if (obj.status && obj.status !== "all") params.set("status", obj.status); if (obj.minBudget !== "") params.set("minBudget", String(obj.minBudget)); if (obj.maxBudget !== "") params.set("maxBudget", String(obj.maxBudget)); params.set("page", String(obj.page || 1)); params.set("pageSize", String(obj.pageSize || 10)); params.set("sortBy", obj.sortBy || "created_at"); params.set("sortOrder", obj.sortOrder || "desc"); const newUrl = `${window.location.pathname}?${params.toString()}`; window.history.replaceState({}, "", newUrl); setUrlParams(params); } } catch (_) { } } }, []); const search = urlParams.get("q") || ""; const qField = urlParams.get("qField") || "all"; const createdFrom = urlParams.get("createdFrom") || ""; const createdTo = urlParams.get("createdTo") || ""; const statusFilter = urlParams.get("status") || "all"; const minBudget = urlParams.get("minBudget") || ""; const maxBudget = urlParams.get("maxBudget") || ""; const page = parseInt(urlParams.get("page") || "1", 10); const pageSize = parseInt(urlParams.get("pageSize") || "10", 10); const sortBy = urlParams.get("sortBy") || "created_at"; const sortOrder = urlParams.get("sortOrder") || "desc"; const updateParams = (updates) => { const params = new URLSearchParams(urlParams.toString()); Object.entries(updates).forEach(([key, value]) => { if (value === "" || value === null || value === void 0) { params.delete(key); } else { params.set(key, String(value)); } }); const newUrl = `${window.location.pathname}?${params.toString()}`; window.history.pushState({}, "", newUrl); setUrlParams(params); }; (0, import_react.useEffect)(() => { if (typeof window === "undefined") return; const obj = { q: search, qField, createdFrom, createdTo, status: statusFilter, minBudget, maxBudget, page, pageSize, sortBy, sortOrder }; try { localStorage.setItem("dashboardTableState", JSON.stringify(obj)); localStorage.setItem("dashboardDensity", compact ? "compact" : "comfy"); localStorage.setItem("dashboardAutoRefresh", autoRefresh ? "1" : "0"); localStorage.setItem("dashboardSuperCompact", superCompact ? "1" : "0"); localStorage.setItem("dashboardWrapDesc", wrapDesc ? "1" : "0"); } catch (_) { } }, [ search, qField, createdFrom, createdTo, statusFilter, minBudget, maxBudget, page, pageSize, sortBy, sortOrder, compact, autoRefresh, superCompact, wrapDesc ]); (0, import_react.useEffect)(() => { if (typeof window === "undefined") return; try { localStorage.setItem( "dashboardSelectedIds", JSON.stringify(Array.from(selectedIds)) ); localStorage.setItem( "dashboardSelectAllActive", selectAllActive ? "1" : "0" ); localStorage.setItem( "dashboardExcludedIds", JSON.stringify(Array.from(excludedIds)) ); } catch (_) { } }, [selectedIds, selectAllActive, excludedIds]); const clearSelection = (0, import_react.useCallback)(() => { setSelectedIds(/* @__PURE__ */ new Set()); setExcludedIds(/* @__PURE__ */ new Set()); setSelectAllActive(false); }, []); const toggleRow = (0, import_react.useCallback)( (id, checked) => { if (selectAllActive) { setExcludedIds((prev) => { const next = new Set(prev); if (checked) next.delete(id); else next.add(id); return next; }); } else { setSelectedIds((prev) => { const next = new Set(prev); if (checked) next.add(id); else next.delete(id); return next; }); } }, [selectAllActive] ); const selectPage = (0, import_react.useCallback)( (ids, checked) => { if (!Array.isArray(ids) || ids.length === 0) return; if (selectAllActive) { setExcludedIds((prev) => { const next = new Set(prev); ids.forEach((id) => { if (checked) next.delete(id); else next.add(id); }); return next; }); } else { setSelectedIds((prev) => { const next = new Set(prev); ids.forEach((id) => { if (checked) next.add(id); else next.delete(id); }); return next; }); } }, [selectAllActive] ); const setSelectAll = (0, import_react.useCallback)((active) => { setSelectAllActive(Boolean(active)); if (active) setExcludedIds(/* @__PURE__ */ new Set()); }, []); return { urlParams, search, qField, createdFrom, createdTo, statusFilter, minBudget, maxBudget, page, pageSize, sortBy, sortOrder, updateParams, presets, setPresets, selectedPreset, setSelectedPreset, compact, setCompact, autoRefresh, setAutoRefresh, // NEW: exposed toggles superCompact, setSuperCompact, wrapDesc, setWrapDesc, // NEW: selection state selectedIds, setSelectedIds, selectAllActive, setSelectAllActive: setSelectAll, excludedIds, setExcludedIds, toggleRow, selectPage, clearSelection }; } // virtual:/apps/web/src/hooks/useDashboardData.js init_injected_globals(); var import_react2 = __toESM(require_react()); function useDashboardData({ search, qField, createdFrom, createdTo, minBudget, maxBudget, statusFilter, page, pageSize, sortBy, sortOrder, autoRefresh }) { const queryString = (0, import_react2.useMemo)(() => { const params = new URLSearchParams(); if (search.trim()) params.set("q", search.trim()); if (qField && qField !== "all") params.set("qField", qField); if (createdFrom) params.set("createdFrom", createdFrom); if (createdTo) params.set("createdTo", createdTo); if (minBudget !== "" && !Number.isNaN(Number(minBudget))) params.set("minBudget", String(minBudget)); if (maxBudget !== "" && !Number.isNaN(Number(maxBudget))) params.set("maxBudget", String(maxBudget)); if (statusFilter !== "all") params.set("status", statusFilter); params.set("page", String(page)); params.set("pageSize", String(pageSize)); params.set("sortBy", sortBy); params.set("sortOrder", sortOrder); return params.toString(); }, [ search, qField, createdFrom, createdTo, minBudget, maxBudget, statusFilter, page, pageSize, sortBy, sortOrder ]); const { data, isLoading, isError, error, isFetching } = useQuery({ queryKey: ["jobs", queryString], queryFn: async () => { const url = `/api/jobs?${queryString}`; const res = await fetch(url); if (!res.ok) { throw new Error( `When fetching ${url}, the response was [${res.status}] ${res.statusText}` ); } return res.json(); }, keepPreviousData: true, refetchInterval: autoRefresh ? 6e4 : false }); const rows = data?.jobs || []; const total = data?.total || 0; const totalPages = Math.ceil(total / pageSize); const totalsByStatus = data?.totalsByStatus || null; return { rows, total, totalPages, totalsByStatus, isLoading, isError, error, isFetching }; } // virtual:/apps/web/src/hooks/useSavedViews.js init_injected_globals(); function useSavedViews(isAuthed) { const queryClient2 = useQueryClient(); const { data: cloudData, isLoading: cloudLoading } = useQuery({ queryKey: ["saved-views"], enabled: isAuthed, queryFn: async () => { const res = await fetch("/api/views", { cache: "no-store" }); if (!res.ok) { throw new Error( `When fetching /api/views, the response was [${res.status}] ${res.statusText}` ); } return res.json(); }, staleTime: 3e4 }); const cloudPresets = (cloudData?.views || []).reduce((acc, v) => { acc[v.name] = v.params || {}; return acc; }, {}); const saveViewMutation = useMutation({ mutationFn: async ({ name, params }) => { const res = await fetch("/api/views", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ name, params }) }); if (!res.ok) { throw new Error( `When saving view, the response was [${res.status}] ${res.statusText}` ); } return res.json(); }, onSuccess: () => { queryClient2.invalidateQueries({ queryKey: ["saved-views"] }); } }); const deleteViewMutation = useMutation({ mutationFn: async ({ name }) => { const url = new URL("/api/views", window.location.origin); url.searchParams.set("name", name); const res = await fetch(url.toString(), { method: "DELETE" }); if (!res.ok) { throw new Error( `When deleting view, the response was [${res.status}] ${res.statusText}` ); } return res.json(); }, onSuccess: () => { queryClient2.invalidateQueries({ queryKey: ["saved-views"] }); } }); return { cloudPresets, cloudLoading, saveViewMutation, deleteViewMutation }; } // virtual:/apps/web/src/hooks/useDashboardActions.js init_injected_globals(); // virtual:/apps/web/src/utils/dateHelpers.js init_injected_globals(); function formatDate(d) { const y = d.getFullYear(); const m = String(d.getMonth() + 1).padStart(2, "0"); const day = String(d.getDate()).padStart(2, "0"); return `${y}-${m}-${day}`; } function getToday() { return formatDate(/* @__PURE__ */ new Date()); } function getDaysAgo(days) { const now = /* @__PURE__ */ new Date(); const start = new Date(now.getTime() - (days - 1) * 24 * 60 * 60 * 1e3); return { from: formatDate(start), to: formatDate(now) }; } // virtual:/apps/web/src/hooks/useDashboardActions.js function useDashboardActions({ urlParams, updateParams, isAuthed, presets, setPresets, selectedPreset, setSelectedPreset, effectivePresets, saveViewMutation, deleteViewMutation }) { const handleExportCsv = () => { const p = new URLSearchParams(urlParams.toString()); p.set("format", "csv"); window.open(`/api/jobs?${p.toString()}`, "_blank"); }; const handleReset = () => { const params = new URLSearchParams(); params.set("page", "1"); params.set("pageSize", "10"); params.set("sortBy", "created_at"); params.set("sortOrder", "desc"); const newUrl = `${window.location.pathname}?${params.toString()}`; window.history.pushState({}, "", newUrl); updateParams({ q: "", qField: "all", createdFrom: "", createdTo: "", status: "all", minBudget: "", maxBudget: "", page: 1, pageSize: 10, sortBy: "created_at", sortOrder: "desc" }); try { localStorage.removeItem("dashboardTableState"); } catch (_) { } }; const applyToday = () => { const today = getToday(); updateParams({ createdFrom: today, createdTo: today, page: 1 }); }; const apply7d = () => { const range = getDaysAgo(7); updateParams({ createdFrom: range.from, createdTo: range.to, page: 1 }); }; const apply30d = () => { const range = getDaysAgo(30); updateParams({ createdFrom: range.from, createdTo: range.to, page: 1 }); }; const saveCurrentView = () => { const name = window.prompt("Save view as:", "My view"); if (!name) return; const obj = Object.fromEntries(urlParams.entries()); if (isAuthed) { saveViewMutation.mutate({ name, params: obj }); setSelectedPreset(name); return; } const next = { ...presets, [name]: obj }; setPresets(next); try { localStorage.setItem("dashboardViewPresets", JSON.stringify(next)); } catch (_) { } setSelectedPreset(name); }; const applyPreset = () => { if (!selectedPreset) return; const source = effectivePresets; if (!source[selectedPreset]) return; const p = new URLSearchParams(source[selectedPreset]); p.set("page", "1"); const newUrl = `${window.location.pathname}?${p.toString()}`; window.history.pushState({}, "", newUrl); updateParams(Object.fromEntries(p.entries())); }; const deletePreset = () => { if (!selectedPreset) return; if (isAuthed) { deleteViewMutation.mutate({ name: selectedPreset }); setSelectedPreset(""); return; } const { [selectedPreset]: _omit, ...rest } = presets; setPresets(rest); try { localStorage.setItem("dashboardViewPresets", JSON.stringify(rest)); } catch (_) { } setSelectedPreset(""); }; return { handleExportCsv, handleReset, applyToday, apply7d, apply30d, saveCurrentView, applyPreset, deletePreset }; } // virtual:/apps/web/src/components/Dashboard/DashboardHeader.jsx init_injected_globals(); function DashboardHeader({ search, qField, updateParams, compact, setCompact, superCompact, setSuperCompact, wrapDesc, setWrapDesc, autoRefresh, setAutoRefresh, saveCurrentView, selectedPreset, setSelectedPreset, effectivePresets, isAuthed, applyPreset, deletePreset, handleExportCsv, handleReset, isFetching, isLoading }) { return /* @__PURE__ */ React.createElement("div", { className: "flex items-center justify-between gap-4" }, /* @__PURE__ */ React.createElement("div", { className: "flex items-center gap-4 text-sm" }, /* @__PURE__ */ React.createElement("a", { href: "/dashboard", className: "text-white font-medium" }, "Dashboard"), /* @__PURE__ */ React.createElement("a", { href: "/about", className: "text-white/80 hover:text-white" }, "About")), /* @__PURE__ */ React.createElement("div", { className: "w-full max-w-[700px] flex flex-wrap gap-2 justify-end" }, /* @__PURE__ */ React.createElement("div", { className: "flex gap-2 flex-1 min-w-[280px] max-w-[460px]" }, /* @__PURE__ */ React.createElement( "input", { value: search, onChange: (e) => updateParams({ q: e.target.value, page: 1 }), placeholder: "Search...", className: "flex-1 rounded-md bg-white/5 border border-white/10 px-3 py-2 text-sm text-white placeholder-white/60 outline-none focus:border-white/30" } ), /* @__PURE__ */ React.createElement( "select", { value: qField, onChange: (e) => updateParams({ qField: e.target.value, page: 1 }), className: "w-[170px] rounded-md bg-white/5 border border-white/10 px-3 py-2 text-sm text-white outline-none focus:border-white/30", title: "Search in" }, /* @__PURE__ */ React.createElement("option", { value: "all" }, "Title + Description"), /* @__PURE__ */ React.createElement("option", { value: "title" }, "Title only"), /* @__PURE__ */ React.createElement("option", { value: "description" }, "Description only") )), /* @__PURE__ */ React.createElement("div", { className: "flex items-center gap-2" }, /* @__PURE__ */ React.createElement( "button", { onClick: () => setCompact((v) => !v), className: "px-3 py-2 text-xs rounded-md bg-white/5 border border-white/10 hover:bg-white/10 text-white", title: "Toggle density" }, compact ? "Comfy" : "Compact" ), /* @__PURE__ */ React.createElement( "button", { onClick: () => setSuperCompact((v) => !v), className: `px-3 py-2 text-xs rounded-md border ${superCompact ? "bg-white/15 border-white/30 text-white" : "bg-white/5 border-white/10 text-white"}`, title: "Make rows even denser" }, superCompact ? "Denser: On" : "Denser: Off" ), /* @__PURE__ */ React.createElement( "button", { onClick: () => setWrapDesc((v) => !v), className: `px-3 py-2 text-xs rounded-md border ${wrapDesc ? "bg-white/15 border-white/30 text-white" : "bg-white/5 border-white/10 text-white"}`, title: "Toggle wrap on description" }, wrapDesc ? "Wrap desc: On" : "Wrap desc: Off" ), /* @__PURE__ */ React.createElement( "button", { onClick: () => setAutoRefresh((v) => !v), className: `px-3 py-2 text-xs rounded-md border ${autoRefresh ? "bg-white/15 border-white/30 text-white" : "bg-white/5 border-white/10 text-white"}`, title: "Auto refresh every 60s" }, autoRefresh ? "Auto refresh: On" : "Auto refresh: Off" )), /* @__PURE__ */ React.createElement( "button", { onClick: saveCurrentView, className: "px-3 py-2 text-xs rounded-md bg-white/5 border border-white/10 hover:bg-white/10 text-white", title: "Save current view" }, "Save view" ), /* @__PURE__ */ React.createElement("div", { className: "flex items-center gap-2" }, /* @__PURE__ */ React.createElement( "select", { value: selectedPreset, onChange: (e) => setSelectedPreset(e.target.value), className: "rounded-md bg-white/5 border border-white/10 px-2 py-2 text-xs text-white min-w-[160px]" }, /* @__PURE__ */ React.createElement("option", { value: "" }, "Saved views\u2026 ", isAuthed ? "(cloud)" : "(local)"), Object.keys(effectivePresets).map((name) => /* @__PURE__ */ React.createElement("option", { key: name, value: name }, name)) ), /* @__PURE__ */ React.createElement( "button", { onClick: applyPreset, disabled: !selectedPreset, className: "px-3 py-2 text-xs rounded-md bg-white/5 border border-white/10 hover:bg-white/10 text-white disabled:opacity-50" }, "Apply" ), /* @__PURE__ */ React.createElement( "button", { onClick: deletePreset, disabled: !selectedPreset, className: "px-3 py-2 text-xs rounded-md bg-white/5 border border-white/10 hover:bg-white/10 text-white disabled:opacity-50" }, "Delete" )), /* @__PURE__ */ React.createElement( "button", { onClick: handleExportCsv, disabled: isLoading || isFetching, className: "px-3 py-2 text-xs rounded-md bg-white/5 border border-white/10 hover:bg-white/10 text-white disabled:opacity-50", title: "Export current view to CSV" }, isFetching ? "Exporting\u2026" : "Export CSV" ), /* @__PURE__ */ React.createElement( "button", { onClick: handleReset, className: "px-3 py-2 text-xs rounded-md bg-white/5 border border-white/10 hover:bg-white/10 text-white", title: "Reset filters" }, "Reset" ))); } // virtual:/apps/web/src/components/Dashboard/StatusChips.jsx init_injected_globals(); function StatusChips({ totalsByStatus, statusFilter, updateParams }) { if (!totalsByStatus) return null; const statuses = [ { key: "all", label: "All" }, { key: "posted", label: "Posted" }, { key: "offer_sent", label: "Offer sent" }, { key: "contract", label: "Contract" }, { key: "paid", label: "Paid" }, { key: "work", label: "Work" }, { key: "delivered", label: "Delivered" }, { key: "approved", label: "Approved" } ]; return /* @__PURE__ */ React.createElement("div", { className: "mt-3 flex flex-wrap gap-2 text-xs" }, statuses.map((s) => { const active = statusFilter === s.key || s.key === "all" && statusFilter === "all"; const count2 = totalsByStatus[s.key] ?? 0; return /* @__PURE__ */ React.createElement( "button", { key: s.key, onClick: () => updateParams({ status: s.key, page: 1 }), className: `px-3 py-1 rounded-full border ${active ? "bg-white/15 border-white/30 text-white" : "bg-white/5 border-white/10 text-white/80"}` }, s.label, " (", count2, ")" ); })); } // virtual:/apps/web/src/components/Dashboard/FilterControls.jsx init_injected_globals(); function FilterControls({ statusFilter, minBudget, maxBudget, createdFrom, createdTo, updateParams }) { return /* @__PURE__ */ React.createElement("div", { className: "mt-4 grid grid-cols-1 md:grid-cols-5 gap-3" }, /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("label", { className: "block text-xs text-white/60 mb-1" }, "Status"), /* @__PURE__ */ React.createElement( "select", { value: statusFilter, onChange: (e) => updateParams({ status: e.target.value, page: 1 }), className: "w-full rounded-md bg-white/5 border border-white/10 px-3 py-2 text-sm text-white outline-none focus:border-white/30" }, /* @__PURE__ */ React.createElement("option", { value: "all" }, "All"), /* @__PURE__ */ React.createElement("option", { value: "posted" }, "Posted"), /* @__PURE__ */ React.createElement("option", { value: "offer_sent" }, "Offer sent"), /* @__PURE__ */ React.createElement("option", { value: "contract" }, "Contract"), /* @__PURE__ */ React.createElement("option", { value: "paid" }, "Paid"), /* @__PURE__ */ React.createElement("option", { value: "work" }, "Work"), /* @__PURE__ */ React.createElement("option", { value: "delivered" }, "Delivered"), /* @__PURE__ */ React.createElement("option", { value: "approved" }, "Approved") )), /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("label", { className: "block text-xs text-white/60 mb-1" }, "Min budget ($)"), /* @__PURE__ */ React.createElement( "input", { type: "number", min: "0", value: minBudget, onChange: (e) => updateParams({ minBudget: e.target.value, page: 1 }), placeholder: "0", className: "w-full rounded-md bg-white/5 border border-white/10 px-3 py-2 text-sm text-white placeholder-white/60 outline-none focus:border-white/30" } )), /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("label", { className: "block text-xs text-white/60 mb-1" }, "Max budget ($)"), /* @__PURE__ */ React.createElement( "input", { type: "number", min: "0", value: maxBudget, onChange: (e) => updateParams({ maxBudget: e.target.value, page: 1 }), placeholder: "1000", className: "w-full rounded-md bg-white/5 border border-white/10 px-3 py-2 text-sm text-white placeholder-white/60 outline-none focus:border-white/30" } )), /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("label", { className: "block text-xs text-white/60 mb-1" }, "Created from"), /* @__PURE__ */ React.createElement( "input", { type: "date", value: createdFrom, onChange: (e) => updateParams({ createdFrom: e.target.value, page: 1 }), className: "w-full rounded-md bg-white/5 border border-white/10 px-3 py-2 text-sm text-white outline-none focus:border-white/30" } )), /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("label", { className: "block text-xs text-white/60 mb-1" }, "Created to"), /* @__PURE__ */ React.createElement( "input", { type: "date", value: createdTo, onChange: (e) => updateParams({ createdTo: e.target.value, page: 1 }), className: "w-full rounded-md bg-white/5 border border-white/10 px-3 py-2 text-sm text-white outline-none focus:border-white/30" } ))); } // virtual:/apps/web/src/components/Dashboard/DateRangeChips.jsx init_injected_globals(); function DateRangeChips({ createdFrom, createdTo, applyToday, apply7d, apply30d, updateParams }) { return /* @__PURE__ */ React.createElement("div", { className: "mt-2 flex items-center gap-2 text-xs" }, /* @__PURE__ */ React.createElement("span", { className: "text-white/60" }, "Quick range:"), /* @__PURE__ */ React.createElement( "button", { onClick: applyToday, className: "px-2 py-1 rounded-md border border-white/10 bg-white/5 hover:bg-white/10 text-white" }, "Today" ), /* @__PURE__ */ React.createElement( "button", { onClick: apply7d, className: "px-2 py-1 rounded-md border border-white/10 bg-white/5 hover:bg-white/10 text-white" }, "7 days" ), /* @__PURE__ */ React.createElement( "button", { onClick: apply30d, className: "px-2 py-1 rounded-md border border-white/10 bg-white/5 hover:bg-white/10 text-white" }, "30 days" ), (createdFrom || createdTo) && /* @__PURE__ */ React.createElement( "button", { onClick: () => updateParams({ createdFrom: "", createdTo: "", page: 1 }), className: "ml-2 px-2 py-1 rounded-md border border-white/10 bg-white/5 hover:bg-white/10 text-white", title: "Clear range" }, "Clear" )); } // virtual:/apps/web/src/components/Dashboard/JobsTable.jsx init_injected_globals(); var import_react3 = __toESM(require_react()); // ../../../node_modules/@tanstack/react-table/build/lib/index.mjs init_injected_globals(); var React9 = __toESM(require_react(), 1); // ../../../node_modules/@tanstack/table-core/build/lib/index.mjs init_injected_globals(); function functionalUpdate2(updater, input) { return typeof updater === "function" ? updater(input) : updater; } function makeStateUpdater(key, instance) { return (updater) => { instance.setState((old) => { return { ...old, [key]: functionalUpdate2(updater, old[key]) }; }); }; } function isFunction(d) { return d instanceof Function; } function isNumberArray(d) { return Array.isArray(d) && d.every((val) => typeof val === "number"); } function flattenBy(arr, getChildren) { const flat = []; const recurse = (subArr) => { subArr.forEach((item) => { flat.push(item); const children = getChildren(item); if (children != null && children.length) { recurse(children); } }); }; recurse(arr); return flat; } function memo(getDeps, fn, opts) { let deps = []; let result; return (depArgs) => { let depTime; if (opts.key && opts.debug) depTime = Date.now(); const newDeps = getDeps(depArgs); const depsChanged = newDeps.length !== deps.length || newDeps.some((dep, index) => deps[index] !== dep); if (!depsChanged) { return result; } deps = newDeps; let resultTime; if (opts.key && opts.debug) resultTime = Date.now(); result = fn(...newDeps); opts == null || opts.onChange == null || opts.onChange(result); if (opts.key && opts.debug) { if (opts != null && opts.debug()) { const depEndTime = Math.round((Date.now() - depTime) * 100) / 100; const resultEndTime = Math.round((Date.now() - resultTime) * 100) / 100; const resultFpsPercentage = resultEndTime / 16; const pad = (str, num) => { str = String(str); while (str.length < num) { str = " " + str; } return str; }; console.info(`%c\u23F1 ${pad(resultEndTime, 5)} /${pad(depEndTime, 5)} ms`, ` font-size: .6rem; font-weight: bold; color: hsl(${Math.max(0, Math.min(120 - 120 * resultFpsPercentage, 120))}deg 100% 31%);`, opts == null ? void 0 : opts.key); } } return result; }; } function getMemoOptions(tableOptions, debugLevel, key, onChange) { return { debug: () => { var _tableOptions$debugAl; return (_tableOptions$debugAl = tableOptions == null ? void 0 : tableOptions.debugAll) != null ? _tableOptions$debugAl : tableOptions[debugLevel]; }, key: false, onChange }; } function createCell(table, row, column, columnId) { const getRenderValue = () => { var _cell$getValue; return (_cell$getValue = cell.getValue()) != null ? _cell$getValue : table.options.renderFallbackValue; }; const cell = { id: `${row.id}_${column.id}`, row, column, getValue: () => row.getValue(columnId), renderValue: getRenderValue, getContext: memo(() => [table, column, row, cell], (table2, column2, row2, cell2) => ({ table: table2, column: column2, row: row2, cell: cell2, getValue: cell2.getValue, renderValue: cell2.renderValue }), getMemoOptions(table.options, "debugCells", "cell.getContext")) }; table._features.forEach((feature) => { feature.createCell == null || feature.createCell(cell, column, row, table); }, {}); return cell; } function createColumn(table, columnDef, depth, parent) { var _ref, _resolvedColumnDef$id; const defaultColumn = table._getDefaultColumnDef(); const resolvedColumnDef = { ...defaultColumn, ...columnDef }; const accessorKey = resolvedColumnDef.accessorKey; let id = (_ref = (_resolvedColumnDef$id = resolvedColumnDef.id) != null ? _resolvedColumnDef$id : accessorKey ? typeof String.prototype.replaceAll === "function" ? accessorKey.replaceAll(".", "_") : accessorKey.replace(/\./g, "_") : void 0) != null ? _ref : typeof resolvedColumnDef.header === "string" ? resolvedColumnDef.header : void 0; let accessorFn; if (resolvedColumnDef.accessorFn) { accessorFn = resolvedColumnDef.accessorFn; } else if (accessorKey) { if (accessorKey.includes(".")) { accessorFn = (originalRow) => { let result = originalRow; for (const key of accessorKey.split(".")) { var _result; result = (_result = result) == null ? void 0 : _result[key]; if (false) { console.warn(`"${key}" in deeply nested key "${accessorKey}" returned undefined.`); } } return result; }; } else { accessorFn = (originalRow) => originalRow[resolvedColumnDef.accessorKey]; } } if (!id) { if (false) { throw new Error(resolvedColumnDef.accessorFn ? `Columns require an id when using an accessorFn` : `Columns require an id when using a non-string header`); } throw new Error(); } let column = { id: `${String(id)}`, accessorFn, parent, depth, columnDef: resolvedColumnDef, columns: [], getFlatColumns: memo(() => [true], () => { var _column$columns; return [column, ...(_column$columns = column.columns) == null ? void 0 : _column$columns.flatMap((d) => d.getFlatColumns())]; }, getMemoOptions(table.options, "debugColumns", "column.getFlatColumns")), getLeafColumns: memo(() => [table._getOrderColumnsFn()], (orderColumns2) => { var _column$columns2; if ((_column$columns2 = column.columns) != null && _column$columns2.length) { let leafColumns = column.columns.flatMap((column2) => column2.getLeafColumns()); return orderColumns2(leafColumns); } return [column]; }, getMemoOptions(table.options, "debugColumns", "column.getLeafColumns")) }; for (const feature of table._features) { feature.createColumn == null || feature.createColumn(column, table); } return column; } var debug = "debugHeaders"; function createHeader(table, column, options) { var _options$id; const id = (_options$id = options.id) != null ? _options$id : column.id; let header = { id, column, index: options.index, isPlaceholder: !!options.isPlaceholder, placeholderId: options.placeholderId, depth: options.depth, subHeaders: [], colSpan: 0, rowSpan: 0, headerGroup: null, getLeafHeaders: () => { const leafHeaders = []; const recurseHeader = (h) => { if (h.subHeaders && h.subHeaders.length) { h.subHeaders.map(recurseHeader); } leafHeaders.push(h); }; recurseHeader(header); return leafHeaders; }, getContext: () => ({ table, header, column }) }; table._features.forEach((feature) => { feature.createHeader == null || feature.createHeader(header, table); }); return header; } var Headers2 = { createTable: (table) => { table.getHeaderGroups = memo(() => [table.getAllColumns(), table.getVisibleLeafColumns(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allColumns, leafColumns, left, right) => { var _left$map$filter, _right$map$filter; const leftColumns = (_left$map$filter = left == null ? void 0 : left.map((columnId) => leafColumns.find((d) => d.id === columnId)).filter(Boolean)) != null ? _left$map$filter : []; const rightColumns = (_right$map$filter = right == null ? void 0 : right.map((columnId) => leafColumns.find((d) => d.id === columnId)).filter(Boolean)) != null ? _right$map$filter : []; const centerColumns = leafColumns.filter((column) => !(left != null && left.includes(column.id)) && !(right != null && right.includes(column.id))); const headerGroups = buildHeaderGroups(allColumns, [...leftColumns, ...centerColumns, ...rightColumns], table); return headerGroups; }, getMemoOptions(table.options, debug, "getHeaderGroups")); table.getCenterHeaderGroups = memo(() => [table.getAllColumns(), table.getVisibleLeafColumns(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allColumns, leafColumns, left, right) => { leafColumns = leafColumns.filter((column) => !(left != null && left.includes(column.id)) && !(right != null && right.includes(column.id))); return buildHeaderGroups(allColumns, leafColumns, table, "center"); }, getMemoOptions(table.options, debug, "getCenterHeaderGroups")); table.getLeftHeaderGroups = memo(() => [table.getAllColumns(), table.getVisibleLeafColumns(), table.getState().columnPinning.left], (allColumns, leafColumns, left) => { var _left$map$filter2; const orderedLeafColumns = (_left$map$filter2 = left == null ? void 0 : left.map((columnId) => leafColumns.find((d) => d.id === columnId)).filter(Boolean)) != null ? _left$map$filter2 : []; return buildHeaderGroups(allColumns, orderedLeafColumns, table, "left"); }, getMemoOptions(table.options, debug, "getLeftHeaderGroups")); table.getRightHeaderGroups = memo(() => [table.getAllColumns(), table.getVisibleLeafColumns(), table.getState().columnPinning.right], (allColumns, leafColumns, right) => { var _right$map$filter2; const orderedLeafColumns = (_right$map$filter2 = right == null ? void 0 : right.map((columnId) => leafColumns.find((d) => d.id === columnId)).filter(Boolean)) != null ? _right$map$filter2 : []; return buildHeaderGroups(allColumns, orderedLeafColumns, table, "right"); }, getMemoOptions(table.options, debug, "getRightHeaderGroups")); table.getFooterGroups = memo(() => [table.getHeaderGroups()], (headerGroups) => { return [...headerGroups].reverse(); }, getMemoOptions(table.options, debug, "getFooterGroups")); table.getLeftFooterGroups = memo(() => [table.getLeftHeaderGroups()], (headerGroups) => { return [...headerGroups].reverse(); }, getMemoOptions(table.options, debug, "getLeftFooterGroups")); table.getCenterFooterGroups = memo(() => [table.getCenterHeaderGroups()], (headerGroups) => { return [...headerGroups].reverse(); }, getMemoOptions(table.options, debug, "getCenterFooterGroups")); table.getRightFooterGroups = memo(() => [table.getRightHeaderGroups()], (headerGroups) => { return [...headerGroups].reverse(); }, getMemoOptions(table.options, debug, "getRightFooterGroups")); table.getFlatHeaders = memo(() => [table.getHeaderGroups()], (headerGroups) => { return headerGroups.map((headerGroup) => { return headerGroup.headers; }).flat(); }, getMemoOptions(table.options, debug, "getFlatHeaders")); table.getLeftFlatHeaders = memo(() => [table.getLeftHeaderGroups()], (left) => { return left.map((headerGroup) => { return headerGroup.headers; }).flat(); }, getMemoOptions(table.options, debug, "getLeftFlatHeaders")); table.getCenterFlatHeaders = memo(() => [table.getCenterHeaderGroups()], (left) => { return left.map((headerGroup) => { return headerGroup.headers; }).flat(); }, getMemoOptions(table.options, debug, "getCenterFlatHeaders")); table.getRightFlatHeaders = memo(() => [table.getRightHeaderGroups()], (left) => { return left.map((headerGroup) => { return headerGroup.headers; }).flat(); }, getMemoOptions(table.options, debug, "getRightFlatHeaders")); table.getCenterLeafHeaders = memo(() => [table.getCenterFlatHeaders()], (flatHeaders) => { return flatHeaders.filter((header) => { var _header$subHeaders; return !((_header$subHeaders = header.subHeaders) != null && _header$subHeaders.length); }); }, getMemoOptions(table.options, debug, "getCenterLeafHeaders")); table.getLeftLeafHeaders = memo(() => [table.getLeftFlatHeaders()], (flatHeaders) => { return flatHeaders.filter((header) => { var _header$subHeaders2; return !((_header$subHeaders2 = header.subHeaders) != null && _header$subHeaders2.length); }); }, getMemoOptions(table.options, debug, "getLeftLeafHeaders")); table.getRightLeafHeaders = memo(() => [table.getRightFlatHeaders()], (flatHeaders) => { return flatHeaders.filter((header) => { var _header$subHeaders3; return !((_header$subHeaders3 = header.subHeaders) != null && _header$subHeaders3.length); }); }, getMemoOptions(table.options, debug, "getRightLeafHeaders")); table.getLeafHeaders = memo(() => [table.getLeftHeaderGroups(), table.getCenterHeaderGroups(), table.getRightHeaderGroups()], (left, center, right) => { var _left$0$headers, _left$, _center$0$headers, _center$, _right$0$headers, _right$; return [...(_left$0$headers = (_left$ = left[0]) == null ? void 0 : _left$.headers) != null ? _left$0$headers : [], ...(_center$0$headers = (_center$ = center[0]) == null ? void 0 : _center$.headers) != null ? _center$0$headers : [], ...(_right$0$headers = (_right$ = right[0]) == null ? void 0 : _right$.headers) != null ? _right$0$headers : []].map((header) => { return header.getLeafHeaders(); }).flat(); }, getMemoOptions(table.options, debug, "getLeafHeaders")); } }; function buildHeaderGroups(allColumns, columnsToGroup, table, headerFamily) { var _headerGroups$0$heade, _headerGroups$; let maxDepth = 0; const findMaxDepth = function(columns, depth) { if (depth === void 0) { depth = 1; } maxDepth = Math.max(maxDepth, depth); columns.filter((column) => column.getIsVisible()).forEach((column) => { var _column$columns; if ((_column$columns = column.columns) != null && _column$columns.length) { findMaxDepth(column.columns, depth + 1); } }, 0); }; findMaxDepth(allColumns); let headerGroups = []; const createHeaderGroup = (headersToGroup, depth) => { const headerGroup = { depth, id: [headerFamily, `${depth}`].filter(Boolean).join("_"), headers: [] }; const pendingParentHeaders = []; headersToGroup.forEach((headerToGroup) => { const latestPendingParentHeader = [...pendingParentHeaders].reverse()[0]; const isLeafHeader = headerToGroup.column.depth === headerGroup.depth; let column; let isPlaceholder = false; if (isLeafHeader && headerToGroup.column.parent) { column = headerToGroup.column.parent; } else { column = headerToGroup.column; isPlaceholder = true; } if (latestPendingParentHeader && (latestPendingParentHeader == null ? void 0 : latestPendingParentHeader.column) === column) { latestPendingParentHeader.subHeaders.push(headerToGroup); } else { const header = createHeader(table, column, { id: [headerFamily, depth, column.id, headerToGroup == null ? void 0 : headerToGroup.id].filter(Boolean).join("_"), isPlaceholder, placeholderId: isPlaceholder ? `${pendingParentHeaders.filter((d) => d.column === column).length}` : void 0, depth, index: pendingParentHeaders.length }); header.subHeaders.push(headerToGroup); pendingParentHeaders.push(header); } headerGroup.headers.push(headerToGroup); headerToGroup.headerGroup = headerGroup; }); headerGroups.push(headerGroup); if (depth > 0) { createHeaderGroup(pendingParentHeaders, depth - 1); } }; const bottomHeaders = columnsToGroup.map((column, index) => createHeader(table, column, { depth: maxDepth, index })); createHeaderGroup(bottomHeaders, maxDepth - 1); headerGroups.reverse(); const recurseHeadersForSpans = (headers) => { const filteredHeaders = headers.filter((header) => header.column.getIsVisible()); return filteredHeaders.map((header) => { let colSpan = 0; let rowSpan = 0; let childRowSpans = [0]; if (header.subHeaders && header.subHeaders.length) { childRowSpans = []; recurseHeadersForSpans(header.subHeaders).forEach((_ref) => { let { colSpan: childColSpan, rowSpan: childRowSpan } = _ref; colSpan += childColSpan; childRowSpans.push(childRowSpan); }); } else { colSpan = 1; } const minChildRowSpan = Math.min(...childRowSpans); rowSpan = rowSpan + minChildRowSpan; header.colSpan = colSpan; header.rowSpan = rowSpan; return { colSpan, rowSpan }; }); }; recurseHeadersForSpans((_headerGroups$0$heade = (_headerGroups$ = headerGroups[0]) == null ? void 0 : _headerGroups$.headers) != null ? _headerGroups$0$heade : []); return headerGroups; } var createRow = (table, id, original, rowIndex, depth, subRows, parentId) => { let row = { id, index: rowIndex, original, depth, parentId, _valuesCache: {}, _uniqueValuesCache: {}, getValue: (columnId) => { if (row._valuesCache.hasOwnProperty(columnId)) { return row._valuesCache[columnId]; } const column = table.getColumn(columnId); if (!(column != null && column.accessorFn)) { return void 0; } row._valuesCache[columnId] = column.accessorFn(row.original, rowIndex); return row._valuesCache[columnId]; }, getUniqueValues: (columnId) => { if (row._uniqueValuesCache.hasOwnProperty(columnId)) { return row._uniqueValuesCache[columnId]; } const column = table.getColumn(columnId); if (!(column != null && column.accessorFn)) { return void 0; } if (!column.columnDef.getUniqueValues) { row._uniqueValuesCache[columnId] = [row.getValue(columnId)]; return row._uniqueValuesCache[columnId]; } row._uniqueValuesCache[columnId] = column.columnDef.getUniqueValues(row.original, rowIndex); return row._uniqueValuesCache[columnId]; }, renderValue: (columnId) => { var _row$getValue; return (_row$getValue = row.getValue(columnId)) != null ? _row$getValue : table.options.renderFallbackValue; }, subRows: subRows != null ? subRows : [], getLeafRows: () => flattenBy(row.subRows, (d) => d.subRows), getParentRow: () => row.parentId ? table.getRow(row.parentId, true) : void 0, getParentRows: () => { let parentRows = []; let currentRow = row; while (true) { const parentRow = currentRow.getParentRow(); if (!parentRow) break; parentRows.push(parentRow); currentRow = parentRow; } return parentRows.reverse(); }, getAllCells: memo(() => [table.getAllLeafColumns()], (leafColumns) => { return leafColumns.map((column) => { return createCell(table, row, column, column.id); }); }, getMemoOptions(table.options, "debugRows", "getAllCells")), _getAllCellsByColumnId: memo(() => [row.getAllCells()], (allCells) => { return allCells.reduce((acc, cell) => { acc[cell.column.id] = cell; return acc; }, {}); }, getMemoOptions(table.options, "debugRows", "getAllCellsByColumnId")) }; for (let i = 0; i < table._features.length; i++) { const feature = table._features[i]; feature == null || feature.createRow == null || feature.createRow(row, table); } return row; }; var ColumnFaceting = { createColumn: (column, table) => { column._getFacetedRowModel = table.options.getFacetedRowModel && table.options.getFacetedRowModel(table, column.id); column.getFacetedRowModel = () => { if (!column._getFacetedRowModel) { return table.getPreFilteredRowModel(); } return column._getFacetedRowModel(); }; column._getFacetedUniqueValues = table.options.getFacetedUniqueValues && table.options.getFacetedUniqueValues(table, column.id); column.getFacetedUniqueValues = () => { if (!column._getFacetedUniqueValues) { return /* @__PURE__ */ new Map(); } return column._getFacetedUniqueValues(); }; column._getFacetedMinMaxValues = table.options.getFacetedMinMaxValues && table.options.getFacetedMinMaxValues(table, column.id); column.getFacetedMinMaxValues = () => { if (!column._getFacetedMinMaxValues) { return void 0; } return column._getFacetedMinMaxValues(); }; } }; var includesString = (row, columnId, filterValue) => { var _filterValue$toString, _row$getValue; const search = filterValue == null || (_filterValue$toString = filterValue.toString()) == null ? void 0 : _filterValue$toString.toLowerCase(); return Boolean((_row$getValue = row.getValue(columnId)) == null || (_row$getValue = _row$getValue.toString()) == null || (_row$getValue = _row$getValue.toLowerCase()) == null ? void 0 : _row$getValue.includes(search)); }; includesString.autoRemove = (val) => testFalsey(val); var includesStringSensitive = (row, columnId, filterValue) => { var _row$getValue2; return Boolean((_row$getValue2 = row.getValue(columnId)) == null || (_row$getValue2 = _row$getValue2.toString()) == null ? void 0 : _row$getValue2.includes(filterValue)); }; includesStringSensitive.autoRemove = (val) => testFalsey(val); var equalsString = (row, columnId, filterValue) => { var _row$getValue3; return ((_row$getValue3 = row.getValue(columnId)) == null || (_row$getValue3 = _row$getValue3.toString()) == null ? void 0 : _row$getValue3.toLowerCase()) === (filterValue == null ? void 0 : filterValue.toLowerCase()); }; equalsString.autoRemove = (val) => testFalsey(val); var arrIncludes = (row, columnId, filterValue) => { var _row$getValue4; return (_row$getValue4 = row.getValue(columnId)) == null ? void 0 : _row$getValue4.includes(filterValue); }; arrIncludes.autoRemove = (val) => testFalsey(val); var arrIncludesAll = (row, columnId, filterValue) => { return !filterValue.some((val) => { var _row$getValue5; return !((_row$getValue5 = row.getValue(columnId)) != null && _row$getValue5.includes(val)); }); }; arrIncludesAll.autoRemove = (val) => testFalsey(val) || !(val != null && val.length); var arrIncludesSome = (row, columnId, filterValue) => { return filterValue.some((val) => { var _row$getValue6; return (_row$getValue6 = row.getValue(columnId)) == null ? void 0 : _row$getValue6.includes(val); }); }; arrIncludesSome.autoRemove = (val) => testFalsey(val) || !(val != null && val.length); var equals = (row, columnId, filterValue) => { return row.getValue(columnId) === filterValue; }; equals.autoRemove = (val) => testFalsey(val); var weakEquals = (row, columnId, filterValue) => { return row.getValue(columnId) == filterValue; }; weakEquals.autoRemove = (val) => testFalsey(val); var inNumberRange = (row, columnId, filterValue) => { let [min2, max2] = filterValue; const rowValue = row.getValue(columnId); return rowValue >= min2 && rowValue <= max2; }; inNumberRange.resolveFilterValue = (val) => { let [unsafeMin, unsafeMax] = val; let parsedMin = typeof unsafeMin !== "number" ? parseFloat(unsafeMin) : unsafeMin; let parsedMax = typeof unsafeMax !== "number" ? parseFloat(unsafeMax) : unsafeMax; let min2 = unsafeMin === null || Number.isNaN(parsedMin) ? -Infinity : parsedMin; let max2 = unsafeMax === null || Number.isNaN(parsedMax) ? Infinity : parsedMax; if (min2 > max2) { const temp = min2; min2 = max2; max2 = temp; } return [min2, max2]; }; inNumberRange.autoRemove = (val) => testFalsey(val) || testFalsey(val[0]) && testFalsey(val[1]); var filterFns = { includesString, includesStringSensitive, equalsString, arrIncludes, arrIncludesAll, arrIncludesSome, equals, weakEquals, inNumberRange }; function testFalsey(val) { return val === void 0 || val === null || val === ""; } var ColumnFiltering = { getDefaultColumnDef: () => { return { filterFn: "auto" }; }, getInitialState: (state) => { return { columnFilters: [], ...state }; }, getDefaultOptions: (table) => { return { onColumnFiltersChange: makeStateUpdater("columnFilters", table), filterFromLeafRows: false, maxLeafRowFilterDepth: 100 }; }, createColumn: (column, table) => { column.getAutoFilterFn = () => { const firstRow = table.getCoreRowModel().flatRows[0]; const value = firstRow == null ? void 0 : firstRow.getValue(column.id); if (typeof value === "string") { return filterFns.includesString; } if (typeof value === "number") { return filterFns.inNumberRange; } if (typeof value === "boolean") { return filterFns.equals; } if (value !== null && typeof value === "object") { return filterFns.equals; } if (Array.isArray(value)) { return filterFns.arrIncludes; } return filterFns.weakEquals; }; column.getFilterFn = () => { var _table$options$filter, _table$options$filter2; return isFunction(column.columnDef.filterFn) ? column.columnDef.filterFn : column.columnDef.filterFn === "auto" ? column.getAutoFilterFn() : ( // @ts-ignore (_table$options$filter = (_table$options$filter2 = table.options.filterFns) == null ? void 0 : _table$options$filter2[column.columnDef.filterFn]) != null ? _table$options$filter : filterFns[column.columnDef.filterFn] ); }; column.getCanFilter = () => { var _column$columnDef$ena, _table$options$enable, _table$options$enable2; return ((_column$columnDef$ena = column.columnDef.enableColumnFilter) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableColumnFilters) != null ? _table$options$enable : true) && ((_table$options$enable2 = table.options.enableFilters) != null ? _table$options$enable2 : true) && !!column.accessorFn; }; column.getIsFiltered = () => column.getFilterIndex() > -1; column.getFilterValue = () => { var _table$getState$colum; return (_table$getState$colum = table.getState().columnFilters) == null || (_table$getState$colum = _table$getState$colum.find((d) => d.id === column.id)) == null ? void 0 : _table$getState$colum.value; }; column.getFilterIndex = () => { var _table$getState$colum2, _table$getState$colum3; return (_table$getState$colum2 = (_table$getState$colum3 = table.getState().columnFilters) == null ? void 0 : _table$getState$colum3.findIndex((d) => d.id === column.id)) != null ? _table$getState$colum2 : -1; }; column.setFilterValue = (value) => { table.setColumnFilters((old) => { const filterFn = column.getFilterFn(); const previousFilter = old == null ? void 0 : old.find((d) => d.id === column.id); const newFilter = functionalUpdate2(value, previousFilter ? previousFilter.value : void 0); if (shouldAutoRemoveFilter(filterFn, newFilter, column)) { var _old$filter; return (_old$filter = old == null ? void 0 : old.filter((d) => d.id !== column.id)) != null ? _old$filter : []; } const newFilterObj = { id: column.id, value: newFilter }; if (previousFilter) { var _old$map; return (_old$map = old == null ? void 0 : old.map((d) => { if (d.id === column.id) { return newFilterObj; } return d; })) != null ? _old$map : []; } if (old != null && old.length) { return [...old, newFilterObj]; } return [newFilterObj]; }); }; }, createRow: (row, _table) => { row.columnFilters = {}; row.columnFiltersMeta = {}; }, createTable: (table) => { table.setColumnFilters = (updater) => { const leafColumns = table.getAllLeafColumns(); const updateFn = (old) => { var _functionalUpdate; return (_functionalUpdate = functionalUpdate2(updater, old)) == null ? void 0 : _functionalUpdate.filter((filter) => { const column = leafColumns.find((d) => d.id === filter.id); if (column) { const filterFn = column.getFilterFn(); if (shouldAutoRemoveFilter(filterFn, filter.value, column)) { return false; } } return true; }); }; table.options.onColumnFiltersChange == null || table.options.onColumnFiltersChange(updateFn); }; table.resetColumnFilters = (defaultState) => { var _table$initialState$c, _table$initialState; table.setColumnFilters(defaultState ? [] : (_table$initialState$c = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.columnFilters) != null ? _table$initialState$c : []); }; table.getPreFilteredRowModel = () => table.getCoreRowModel(); table.getFilteredRowModel = () => { if (!table._getFilteredRowModel && table.options.getFilteredRowModel) { table._getFilteredRowModel = table.options.getFilteredRowModel(table); } if (table.options.manualFiltering || !table._getFilteredRowModel) { return table.getPreFilteredRowModel(); } return table._getFilteredRowModel(); }; } }; function shouldAutoRemoveFilter(filterFn, value, column) { return (filterFn && filterFn.autoRemove ? filterFn.autoRemove(value, column) : false) || typeof value === "undefined" || typeof value === "string" && !value; } var sum = (columnId, _leafRows, childRows) => { return childRows.reduce((sum2, next) => { const nextValue = next.getValue(columnId); return sum2 + (typeof nextValue === "number" ? nextValue : 0); }, 0); }; var min = (columnId, _leafRows, childRows) => { let min2; childRows.forEach((row) => { const value = row.getValue(columnId); if (value != null && (min2 > value || min2 === void 0 && value >= value)) { min2 = value; } }); return min2; }; var max = (columnId, _leafRows, childRows) => { let max2; childRows.forEach((row) => { const value = row.getValue(columnId); if (value != null && (max2 < value || max2 === void 0 && value >= value)) { max2 = value; } }); return max2; }; var extent = (columnId, _leafRows, childRows) => { let min2; let max2; childRows.forEach((row) => { const value = row.getValue(columnId); if (value != null) { if (min2 === void 0) { if (value >= value) min2 = max2 = value; } else { if (min2 > value) min2 = value; if (max2 < value) max2 = value; } } }); return [min2, max2]; }; var mean = (columnId, leafRows) => { let count2 = 0; let sum2 = 0; leafRows.forEach((row) => { let value = row.getValue(columnId); if (value != null && (value = +value) >= value) { ++count2, sum2 += value; } }); if (count2) return sum2 / count2; return; }; var median = (columnId, leafRows) => { if (!leafRows.length) { return; } const values = leafRows.map((row) => row.getValue(columnId)); if (!isNumberArray(values)) { return; } if (values.length === 1) { return values[0]; } const mid = Math.floor(values.length / 2); const nums = values.sort((a, b) => a - b); return values.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2; }; var unique = (columnId, leafRows) => { return Array.from(new Set(leafRows.map((d) => d.getValue(columnId))).values()); }; var uniqueCount = (columnId, leafRows) => { return new Set(leafRows.map((d) => d.getValue(columnId))).size; }; var count = (_columnId, leafRows) => { return leafRows.length; }; var aggregationFns = { sum, min, max, extent, mean, median, unique, uniqueCount, count }; var ColumnGrouping = { getDefaultColumnDef: () => { return { aggregatedCell: (props) => { var _toString, _props$getValue; return (_toString = (_props$getValue = props.getValue()) == null || _props$getValue.toString == null ? void 0 : _props$getValue.toString()) != null ? _toString : null; }, aggregationFn: "auto" }; }, getInitialState: (state) => { return { grouping: [], ...state }; }, getDefaultOptions: (table) => { return { onGroupingChange: makeStateUpdater("grouping", table), groupedColumnMode: "reorder" }; }, createColumn: (column, table) => { column.toggleGrouping = () => { table.setGrouping((old) => { if (old != null && old.includes(column.id)) { return old.filter((d) => d !== column.id); } return [...old != null ? old : [], column.id]; }); }; column.getCanGroup = () => { var _column$columnDef$ena, _table$options$enable; return ((_column$columnDef$ena = column.columnDef.enableGrouping) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableGrouping) != null ? _table$options$enable : true) && (!!column.accessorFn || !!column.columnDef.getGroupingValue); }; column.getIsGrouped = () => { var _table$getState$group; return (_table$getState$group = table.getState().grouping) == null ? void 0 : _table$getState$group.includes(column.id); }; column.getGroupedIndex = () => { var _table$getState$group2; return (_table$getState$group2 = table.getState().grouping) == null ? void 0 : _table$getState$group2.indexOf(column.id); }; column.getToggleGroupingHandler = () => { const canGroup = column.getCanGroup(); return () => { if (!canGroup) return; column.toggleGrouping(); }; }; column.getAutoAggregationFn = () => { const firstRow = table.getCoreRowModel().flatRows[0]; const value = firstRow == null ? void 0 : firstRow.getValue(column.id); if (typeof value === "number") { return aggregationFns.sum; } if (Object.prototype.toString.call(value) === "[object Date]") { return aggregationFns.extent; } }; column.getAggregationFn = () => { var _table$options$aggreg, _table$options$aggreg2; if (!column) { throw new Error(); } return isFunction(column.columnDef.aggregationFn) ? column.columnDef.aggregationFn : column.columnDef.aggregationFn === "auto" ? column.getAutoAggregationFn() : (_table$options$aggreg = (_table$options$aggreg2 = table.options.aggregationFns) == null ? void 0 : _table$options$aggreg2[column.columnDef.aggregationFn]) != null ? _table$options$aggreg : aggregationFns[column.columnDef.aggregationFn]; }; }, createTable: (table) => { table.setGrouping = (updater) => table.options.onGroupingChange == null ? void 0 : table.options.onGroupingChange(updater); table.resetGrouping = (defaultState) => { var _table$initialState$g, _table$initialState; table.setGrouping(defaultState ? [] : (_table$initialState$g = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.grouping) != null ? _table$initialState$g : []); }; table.getPreGroupedRowModel = () => table.getFilteredRowModel(); table.getGroupedRowModel = () => { if (!table._getGroupedRowModel && table.options.getGroupedRowModel) { table._getGroupedRowModel = table.options.getGroupedRowModel(table); } if (table.options.manualGrouping || !table._getGroupedRowModel) { return table.getPreGroupedRowModel(); } return table._getGroupedRowModel(); }; }, createRow: (row, table) => { row.getIsGrouped = () => !!row.groupingColumnId; row.getGroupingValue = (columnId) => { if (row._groupingValuesCache.hasOwnProperty(columnId)) { return row._groupingValuesCache[columnId]; } const column = table.getColumn(columnId); if (!(column != null && column.columnDef.getGroupingValue)) { return row.getValue(columnId); } row._groupingValuesCache[columnId] = column.columnDef.getGroupingValue(row.original); return row._groupingValuesCache[columnId]; }; row._groupingValuesCache = {}; }, createCell: (cell, column, row, table) => { cell.getIsGrouped = () => column.getIsGrouped() && column.id === row.groupingColumnId; cell.getIsPlaceholder = () => !cell.getIsGrouped() && column.getIsGrouped(); cell.getIsAggregated = () => { var _row$subRows; return !cell.getIsGrouped() && !cell.getIsPlaceholder() && !!((_row$subRows = row.subRows) != null && _row$subRows.length); }; } }; function orderColumns(leafColumns, grouping, groupedColumnMode) { if (!(grouping != null && grouping.length) || !groupedColumnMode) { return leafColumns; } const nonGroupingColumns = leafColumns.filter((col) => !grouping.includes(col.id)); if (groupedColumnMode === "remove") { return nonGroupingColumns; } const groupingColumns = grouping.map((g) => leafColumns.find((col) => col.id === g)).filter(Boolean); return [...groupingColumns, ...nonGroupingColumns]; } var ColumnOrdering = { getInitialState: (state) => { return { columnOrder: [], ...state }; }, getDefaultOptions: (table) => { return { onColumnOrderChange: makeStateUpdater("columnOrder", table) }; }, createColumn: (column, table) => { column.getIndex = memo((position) => [_getVisibleLeafColumns(table, position)], (columns) => columns.findIndex((d) => d.id === column.id), getMemoOptions(table.options, "debugColumns", "getIndex")); column.getIsFirstColumn = (position) => { var _columns$; const columns = _getVisibleLeafColumns(table, position); return ((_columns$ = columns[0]) == null ? void 0 : _columns$.id) === column.id; }; column.getIsLastColumn = (position) => { var _columns; const columns = _getVisibleLeafColumns(table, position); return ((_columns = columns[columns.length - 1]) == null ? void 0 : _columns.id) === column.id; }; }, createTable: (table) => { table.setColumnOrder = (updater) => table.options.onColumnOrderChange == null ? void 0 : table.options.onColumnOrderChange(updater); table.resetColumnOrder = (defaultState) => { var _table$initialState$c; table.setColumnOrder(defaultState ? [] : (_table$initialState$c = table.initialState.columnOrder) != null ? _table$initialState$c : []); }; table._getOrderColumnsFn = memo(() => [table.getState().columnOrder, table.getState().grouping, table.options.groupedColumnMode], (columnOrder, grouping, groupedColumnMode) => (columns) => { let orderedColumns = []; if (!(columnOrder != null && columnOrder.length)) { orderedColumns = columns; } else { const columnOrderCopy = [...columnOrder]; const columnsCopy = [...columns]; while (columnsCopy.length && columnOrderCopy.length) { const targetColumnId = columnOrderCopy.shift(); const foundIndex = columnsCopy.findIndex((d) => d.id === targetColumnId); if (foundIndex > -1) { orderedColumns.push(columnsCopy.splice(foundIndex, 1)[0]); } } orderedColumns = [...orderedColumns, ...columnsCopy]; } return orderColumns(orderedColumns, grouping, groupedColumnMode); }, getMemoOptions(table.options, "debugTable", "_getOrderColumnsFn")); } }; var getDefaultColumnPinningState = () => ({ left: [], right: [] }); var ColumnPinning = { getInitialState: (state) => { return { columnPinning: getDefaultColumnPinningState(), ...state }; }, getDefaultOptions: (table) => { return { onColumnPinningChange: makeStateUpdater("columnPinning", table) }; }, createColumn: (column, table) => { column.pin = (position) => { const columnIds = column.getLeafColumns().map((d) => d.id).filter(Boolean); table.setColumnPinning((old) => { var _old$left3, _old$right3; if (position === "right") { var _old$left, _old$right; return { left: ((_old$left = old == null ? void 0 : old.left) != null ? _old$left : []).filter((d) => !(columnIds != null && columnIds.includes(d))), right: [...((_old$right = old == null ? void 0 : old.right) != null ? _old$right : []).filter((d) => !(columnIds != null && columnIds.includes(d))), ...columnIds] }; } if (position === "left") { var _old$left2, _old$right2; return { left: [...((_old$left2 = old == null ? void 0 : old.left) != null ? _old$left2 : []).filter((d) => !(columnIds != null && columnIds.includes(d))), ...columnIds], right: ((_old$right2 = old == null ? void 0 : old.right) != null ? _old$right2 : []).filter((d) => !(columnIds != null && columnIds.includes(d))) }; } return { left: ((_old$left3 = old == null ? void 0 : old.left) != null ? _old$left3 : []).filter((d) => !(columnIds != null && columnIds.includes(d))), right: ((_old$right3 = old == null ? void 0 : old.right) != null ? _old$right3 : []).filter((d) => !(columnIds != null && columnIds.includes(d))) }; }); }; column.getCanPin = () => { const leafColumns = column.getLeafColumns(); return leafColumns.some((d) => { var _d$columnDef$enablePi, _ref, _table$options$enable; return ((_d$columnDef$enablePi = d.columnDef.enablePinning) != null ? _d$columnDef$enablePi : true) && ((_ref = (_table$options$enable = table.options.enableColumnPinning) != null ? _table$options$enable : table.options.enablePinning) != null ? _ref : true); }); }; column.getIsPinned = () => { const leafColumnIds = column.getLeafColumns().map((d) => d.id); const { left, right } = table.getState().columnPinning; const isLeft = leafColumnIds.some((d) => left == null ? void 0 : left.includes(d)); const isRight = leafColumnIds.some((d) => right == null ? void 0 : right.includes(d)); return isLeft ? "left" : isRight ? "right" : false; }; column.getPinnedIndex = () => { var _table$getState$colum, _table$getState$colum2; const position = column.getIsPinned(); return position ? (_table$getState$colum = (_table$getState$colum2 = table.getState().columnPinning) == null || (_table$getState$colum2 = _table$getState$colum2[position]) == null ? void 0 : _table$getState$colum2.indexOf(column.id)) != null ? _table$getState$colum : -1 : 0; }; }, createRow: (row, table) => { row.getCenterVisibleCells = memo(() => [row._getAllVisibleCells(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allCells, left, right) => { const leftAndRight = [...left != null ? left : [], ...right != null ? right : []]; return allCells.filter((d) => !leftAndRight.includes(d.column.id)); }, getMemoOptions(table.options, "debugRows", "getCenterVisibleCells")); row.getLeftVisibleCells = memo(() => [row._getAllVisibleCells(), table.getState().columnPinning.left], (allCells, left) => { const cells = (left != null ? left : []).map((columnId) => allCells.find((cell) => cell.column.id === columnId)).filter(Boolean).map((d) => ({ ...d, position: "left" })); return cells; }, getMemoOptions(table.options, "debugRows", "getLeftVisibleCells")); row.getRightVisibleCells = memo(() => [row._getAllVisibleCells(), table.getState().columnPinning.right], (allCells, right) => { const cells = (right != null ? right : []).map((columnId) => allCells.find((cell) => cell.column.id === columnId)).filter(Boolean).map((d) => ({ ...d, position: "right" })); return cells; }, getMemoOptions(table.options, "debugRows", "getRightVisibleCells")); }, createTable: (table) => { table.setColumnPinning = (updater) => table.options.onColumnPinningChange == null ? void 0 : table.options.onColumnPinningChange(updater); table.resetColumnPinning = (defaultState) => { var _table$initialState$c, _table$initialState; return table.setColumnPinning(defaultState ? getDefaultColumnPinningState() : (_table$initialState$c = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.columnPinning) != null ? _table$initialState$c : getDefaultColumnPinningState()); }; table.getIsSomeColumnsPinned = (position) => { var _pinningState$positio; const pinningState = table.getState().columnPinning; if (!position) { var _pinningState$left, _pinningState$right; return Boolean(((_pinningState$left = pinningState.left) == null ? void 0 : _pinningState$left.length) || ((_pinningState$right = pinningState.right) == null ? void 0 : _pinningState$right.length)); } return Boolean((_pinningState$positio = pinningState[position]) == null ? void 0 : _pinningState$positio.length); }; table.getLeftLeafColumns = memo(() => [table.getAllLeafColumns(), table.getState().columnPinning.left], (allColumns, left) => { return (left != null ? left : []).map((columnId) => allColumns.find((column) => column.id === columnId)).filter(Boolean); }, getMemoOptions(table.options, "debugColumns", "getLeftLeafColumns")); table.getRightLeafColumns = memo(() => [table.getAllLeafColumns(), table.getState().columnPinning.right], (allColumns, right) => { return (right != null ? right : []).map((columnId) => allColumns.find((column) => column.id === columnId)).filter(Boolean); }, getMemoOptions(table.options, "debugColumns", "getRightLeafColumns")); table.getCenterLeafColumns = memo(() => [table.getAllLeafColumns(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allColumns, left, right) => { const leftAndRight = [...left != null ? left : [], ...right != null ? right : []]; return allColumns.filter((d) => !leftAndRight.includes(d.id)); }, getMemoOptions(table.options, "debugColumns", "getCenterLeafColumns")); } }; function safelyAccessDocument(_document) { return _document || (typeof document !== "undefined" ? document : null); } var defaultColumnSizing = { size: 150, minSize: 20, maxSize: Number.MAX_SAFE_INTEGER }; var getDefaultColumnSizingInfoState = () => ({ startOffset: null, startSize: null, deltaOffset: null, deltaPercentage: null, isResizingColumn: false, columnSizingStart: [] }); var ColumnSizing = { getDefaultColumnDef: () => { return defaultColumnSizing; }, getInitialState: (state) => { return { columnSizing: {}, columnSizingInfo: getDefaultColumnSizingInfoState(), ...state }; }, getDefaultOptions: (table) => { return { columnResizeMode: "onEnd", columnResizeDirection: "ltr", onColumnSizingChange: makeStateUpdater("columnSizing", table), onColumnSizingInfoChange: makeStateUpdater("columnSizingInfo", table) }; }, createColumn: (column, table) => { column.getSize = () => { var _column$columnDef$min, _ref, _column$columnDef$max; const columnSize = table.getState().columnSizing[column.id]; return Math.min(Math.max((_column$columnDef$min = column.columnDef.minSize) != null ? _column$columnDef$min : defaultColumnSizing.minSize, (_ref = columnSize != null ? columnSize : column.columnDef.size) != null ? _ref : defaultColumnSizing.size), (_column$columnDef$max = column.columnDef.maxSize) != null ? _column$columnDef$max : defaultColumnSizing.maxSize); }; column.getStart = memo((position) => [position, _getVisibleLeafColumns(table, position), table.getState().columnSizing], (position, columns) => columns.slice(0, column.getIndex(position)).reduce((sum2, column2) => sum2 + column2.getSize(), 0), getMemoOptions(table.options, "debugColumns", "getStart")); column.getAfter = memo((position) => [position, _getVisibleLeafColumns(table, position), table.getState().columnSizing], (position, columns) => columns.slice(column.getIndex(position) + 1).reduce((sum2, column2) => sum2 + column2.getSize(), 0), getMemoOptions(table.options, "debugColumns", "getAfter")); column.resetSize = () => { table.setColumnSizing((_ref2) => { let { [column.id]: _, ...rest } = _ref2; return rest; }); }; column.getCanResize = () => { var _column$columnDef$ena, _table$options$enable; return ((_column$columnDef$ena = column.columnDef.enableResizing) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableColumnResizing) != null ? _table$options$enable : true); }; column.getIsResizing = () => { return table.getState().columnSizingInfo.isResizingColumn === column.id; }; }, createHeader: (header, table) => { header.getSize = () => { let sum2 = 0; const recurse = (header2) => { if (header2.subHeaders.length) { header2.subHeaders.forEach(recurse); } else { var _header$column$getSiz; sum2 += (_header$column$getSiz = header2.column.getSize()) != null ? _header$column$getSiz : 0; } }; recurse(header); return sum2; }; header.getStart = () => { if (header.index > 0) { const prevSiblingHeader = header.headerGroup.headers[header.index - 1]; return prevSiblingHeader.getStart() + prevSiblingHeader.getSize(); } return 0; }; header.getResizeHandler = (_contextDocument) => { const column = table.getColumn(header.column.id); const canResize = column == null ? void 0 : column.getCanResize(); return (e) => { if (!column || !canResize) { return; } e.persist == null || e.persist(); if (isTouchStartEvent(e)) { if (e.touches && e.touches.length > 1) { return; } } const startSize = header.getSize(); const columnSizingStart = header ? header.getLeafHeaders().map((d) => [d.column.id, d.column.getSize()]) : [[column.id, column.getSize()]]; const clientX = isTouchStartEvent(e) ? Math.round(e.touches[0].clientX) : e.clientX; const newColumnSizing = {}; const updateOffset = (eventType, clientXPos) => { if (typeof clientXPos !== "number") { return; } table.setColumnSizingInfo((old) => { var _old$startOffset, _old$startSize; const deltaDirection = table.options.columnResizeDirection === "rtl" ? -1 : 1; const deltaOffset = (clientXPos - ((_old$startOffset = old == null ? void 0 : old.startOffset) != null ? _old$startOffset : 0)) * deltaDirection; const deltaPercentage = Math.max(deltaOffset / ((_old$startSize = old == null ? void 0 : old.startSize) != null ? _old$startSize : 0), -0.999999); old.columnSizingStart.forEach((_ref3) => { let [columnId, headerSize] = _ref3; newColumnSizing[columnId] = Math.round(Math.max(headerSize + headerSize * deltaPercentage, 0) * 100) / 100; }); return { ...old, deltaOffset, deltaPercentage }; }); if (table.options.columnResizeMode === "onChange" || eventType === "end") { table.setColumnSizing((old) => ({ ...old, ...newColumnSizing })); } }; const onMove = (clientXPos) => updateOffset("move", clientXPos); const onEnd = (clientXPos) => { updateOffset("end", clientXPos); table.setColumnSizingInfo((old) => ({ ...old, isResizingColumn: false, startOffset: null, startSize: null, deltaOffset: null, deltaPercentage: null, columnSizingStart: [] })); }; const contextDocument = safelyAccessDocument(_contextDocument); const mouseEvents = { moveHandler: (e2) => onMove(e2.clientX), upHandler: (e2) => { contextDocument == null || contextDocument.removeEventListener("mousemove", mouseEvents.moveHandler); contextDocument == null || contextDocument.removeEventListener("mouseup", mouseEvents.upHandler); onEnd(e2.clientX); } }; const touchEvents = { moveHandler: (e2) => { if (e2.cancelable) { e2.preventDefault(); e2.stopPropagation(); } onMove(e2.touches[0].clientX); return false; }, upHandler: (e2) => { var _e$touches$; contextDocument == null || contextDocument.removeEventListener("touchmove", touchEvents.moveHandler); contextDocument == null || contextDocument.removeEventListener("touchend", touchEvents.upHandler); if (e2.cancelable) { e2.preventDefault(); e2.stopPropagation(); } onEnd((_e$touches$ = e2.touches[0]) == null ? void 0 : _e$touches$.clientX); } }; const passiveIfSupported = passiveEventSupported() ? { passive: false } : false; if (isTouchStartEvent(e)) { contextDocument == null || contextDocument.addEventListener("touchmove", touchEvents.moveHandler, passiveIfSupported); contextDocument == null || contextDocument.addEventListener("touchend", touchEvents.upHandler, passiveIfSupported); } else { contextDocument == null || contextDocument.addEventListener("mousemove", mouseEvents.moveHandler, passiveIfSupported); contextDocument == null || contextDocument.addEventListener("mouseup", mouseEvents.upHandler, passiveIfSupported); } table.setColumnSizingInfo((old) => ({ ...old, startOffset: clientX, startSize, deltaOffset: 0, deltaPercentage: 0, columnSizingStart, isResizingColumn: column.id })); }; }; }, createTable: (table) => { table.setColumnSizing = (updater) => table.options.onColumnSizingChange == null ? void 0 : table.options.onColumnSizingChange(updater); table.setColumnSizingInfo = (updater) => table.options.onColumnSizingInfoChange == null ? void 0 : table.options.onColumnSizingInfoChange(updater); table.resetColumnSizing = (defaultState) => { var _table$initialState$c; table.setColumnSizing(defaultState ? {} : (_table$initialState$c = table.initialState.columnSizing) != null ? _table$initialState$c : {}); }; table.resetHeaderSizeInfo = (defaultState) => { var _table$initialState$c2; table.setColumnSizingInfo(defaultState ? getDefaultColumnSizingInfoState() : (_table$initialState$c2 = table.initialState.columnSizingInfo) != null ? _table$initialState$c2 : getDefaultColumnSizingInfoState()); }; table.getTotalSize = () => { var _table$getHeaderGroup, _table$getHeaderGroup2; return (_table$getHeaderGroup = (_table$getHeaderGroup2 = table.getHeaderGroups()[0]) == null ? void 0 : _table$getHeaderGroup2.headers.reduce((sum2, header) => { return sum2 + header.getSize(); }, 0)) != null ? _table$getHeaderGroup : 0; }; table.getLeftTotalSize = () => { var _table$getLeftHeaderG, _table$getLeftHeaderG2; return (_table$getLeftHeaderG = (_table$getLeftHeaderG2 = table.getLeftHeaderGroups()[0]) == null ? void 0 : _table$getLeftHeaderG2.headers.reduce((sum2, header) => { return sum2 + header.getSize(); }, 0)) != null ? _table$getLeftHeaderG : 0; }; table.getCenterTotalSize = () => { var _table$getCenterHeade, _table$getCenterHeade2; return (_table$getCenterHeade = (_table$getCenterHeade2 = table.getCenterHeaderGroups()[0]) == null ? void 0 : _table$getCenterHeade2.headers.reduce((sum2, header) => { return sum2 + header.getSize(); }, 0)) != null ? _table$getCenterHeade : 0; }; table.getRightTotalSize = () => { var _table$getRightHeader, _table$getRightHeader2; return (_table$getRightHeader = (_table$getRightHeader2 = table.getRightHeaderGroups()[0]) == null ? void 0 : _table$getRightHeader2.headers.reduce((sum2, header) => { return sum2 + header.getSize(); }, 0)) != null ? _table$getRightHeader : 0; }; } }; var passiveSupported = null; function passiveEventSupported() { if (typeof passiveSupported === "boolean") return passiveSupported; let supported = false; try { const options = { get passive() { supported = true; return false; } }; const noop3 = () => { }; window.addEventListener("test", noop3, options); window.removeEventListener("test", noop3); } catch (err) { supported = false; } passiveSupported = supported; return passiveSupported; } function isTouchStartEvent(e) { return e.type === "touchstart"; } var ColumnVisibility = { getInitialState: (state) => { return { columnVisibility: {}, ...state }; }, getDefaultOptions: (table) => { return { onColumnVisibilityChange: makeStateUpdater("columnVisibility", table) }; }, createColumn: (column, table) => { column.toggleVisibility = (value) => { if (column.getCanHide()) { table.setColumnVisibility((old) => ({ ...old, [column.id]: value != null ? value : !column.getIsVisible() })); } }; column.getIsVisible = () => { var _ref, _table$getState$colum; const childColumns = column.columns; return (_ref = childColumns.length ? childColumns.some((c) => c.getIsVisible()) : (_table$getState$colum = table.getState().columnVisibility) == null ? void 0 : _table$getState$colum[column.id]) != null ? _ref : true; }; column.getCanHide = () => { var _column$columnDef$ena, _table$options$enable; return ((_column$columnDef$ena = column.columnDef.enableHiding) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableHiding) != null ? _table$options$enable : true); }; column.getToggleVisibilityHandler = () => { return (e) => { column.toggleVisibility == null || column.toggleVisibility(e.target.checked); }; }; }, createRow: (row, table) => { row._getAllVisibleCells = memo(() => [row.getAllCells(), table.getState().columnVisibility], (cells) => { return cells.filter((cell) => cell.column.getIsVisible()); }, getMemoOptions(table.options, "debugRows", "_getAllVisibleCells")); row.getVisibleCells = memo(() => [row.getLeftVisibleCells(), row.getCenterVisibleCells(), row.getRightVisibleCells()], (left, center, right) => [...left, ...center, ...right], getMemoOptions(table.options, "debugRows", "getVisibleCells")); }, createTable: (table) => { const makeVisibleColumnsMethod = (key, getColumns) => { return memo(() => [getColumns(), getColumns().filter((d) => d.getIsVisible()).map((d) => d.id).join("_")], (columns) => { return columns.filter((d) => d.getIsVisible == null ? void 0 : d.getIsVisible()); }, getMemoOptions(table.options, "debugColumns", key)); }; table.getVisibleFlatColumns = makeVisibleColumnsMethod("getVisibleFlatColumns", () => table.getAllFlatColumns()); table.getVisibleLeafColumns = makeVisibleColumnsMethod("getVisibleLeafColumns", () => table.getAllLeafColumns()); table.getLeftVisibleLeafColumns = makeVisibleColumnsMethod("getLeftVisibleLeafColumns", () => table.getLeftLeafColumns()); table.getRightVisibleLeafColumns = makeVisibleColumnsMethod("getRightVisibleLeafColumns", () => table.getRightLeafColumns()); table.getCenterVisibleLeafColumns = makeVisibleColumnsMethod("getCenterVisibleLeafColumns", () => table.getCenterLeafColumns()); table.setColumnVisibility = (updater) => table.options.onColumnVisibilityChange == null ? void 0 : table.options.onColumnVisibilityChange(updater); table.resetColumnVisibility = (defaultState) => { var _table$initialState$c; table.setColumnVisibility(defaultState ? {} : (_table$initialState$c = table.initialState.columnVisibility) != null ? _table$initialState$c : {}); }; table.toggleAllColumnsVisible = (value) => { var _value; value = (_value = value) != null ? _value : !table.getIsAllColumnsVisible(); table.setColumnVisibility(table.getAllLeafColumns().reduce((obj, column) => ({ ...obj, [column.id]: !value ? !(column.getCanHide != null && column.getCanHide()) : value }), {})); }; table.getIsAllColumnsVisible = () => !table.getAllLeafColumns().some((column) => !(column.getIsVisible != null && column.getIsVisible())); table.getIsSomeColumnsVisible = () => table.getAllLeafColumns().some((column) => column.getIsVisible == null ? void 0 : column.getIsVisible()); table.getToggleAllColumnsVisibilityHandler = () => { return (e) => { var _target; table.toggleAllColumnsVisible((_target = e.target) == null ? void 0 : _target.checked); }; }; } }; function _getVisibleLeafColumns(table, position) { return !position ? table.getVisibleLeafColumns() : position === "center" ? table.getCenterVisibleLeafColumns() : position === "left" ? table.getLeftVisibleLeafColumns() : table.getRightVisibleLeafColumns(); } var GlobalFaceting = { createTable: (table) => { table._getGlobalFacetedRowModel = table.options.getFacetedRowModel && table.options.getFacetedRowModel(table, "__global__"); table.getGlobalFacetedRowModel = () => { if (table.options.manualFiltering || !table._getGlobalFacetedRowModel) { return table.getPreFilteredRowModel(); } return table._getGlobalFacetedRowModel(); }; table._getGlobalFacetedUniqueValues = table.options.getFacetedUniqueValues && table.options.getFacetedUniqueValues(table, "__global__"); table.getGlobalFacetedUniqueValues = () => { if (!table._getGlobalFacetedUniqueValues) { return /* @__PURE__ */ new Map(); } return table._getGlobalFacetedUniqueValues(); }; table._getGlobalFacetedMinMaxValues = table.options.getFacetedMinMaxValues && table.options.getFacetedMinMaxValues(table, "__global__"); table.getGlobalFacetedMinMaxValues = () => { if (!table._getGlobalFacetedMinMaxValues) { return; } return table._getGlobalFacetedMinMaxValues(); }; } }; var GlobalFiltering = { getInitialState: (state) => { return { globalFilter: void 0, ...state }; }, getDefaultOptions: (table) => { return { onGlobalFilterChange: makeStateUpdater("globalFilter", table), globalFilterFn: "auto", getColumnCanGlobalFilter: (column) => { var _table$getCoreRowMode; const value = (_table$getCoreRowMode = table.getCoreRowModel().flatRows[0]) == null || (_table$getCoreRowMode = _table$getCoreRowMode._getAllCellsByColumnId()[column.id]) == null ? void 0 : _table$getCoreRowMode.getValue(); return typeof value === "string" || typeof value === "number"; } }; }, createColumn: (column, table) => { column.getCanGlobalFilter = () => { var _column$columnDef$ena, _table$options$enable, _table$options$enable2, _table$options$getCol; return ((_column$columnDef$ena = column.columnDef.enableGlobalFilter) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableGlobalFilter) != null ? _table$options$enable : true) && ((_table$options$enable2 = table.options.enableFilters) != null ? _table$options$enable2 : true) && ((_table$options$getCol = table.options.getColumnCanGlobalFilter == null ? void 0 : table.options.getColumnCanGlobalFilter(column)) != null ? _table$options$getCol : true) && !!column.accessorFn; }; }, createTable: (table) => { table.getGlobalAutoFilterFn = () => { return filterFns.includesString; }; table.getGlobalFilterFn = () => { var _table$options$filter, _table$options$filter2; const { globalFilterFn } = table.options; return isFunction(globalFilterFn) ? globalFilterFn : globalFilterFn === "auto" ? table.getGlobalAutoFilterFn() : (_table$options$filter = (_table$options$filter2 = table.options.filterFns) == null ? void 0 : _table$options$filter2[globalFilterFn]) != null ? _table$options$filter : filterFns[globalFilterFn]; }; table.setGlobalFilter = (updater) => { table.options.onGlobalFilterChange == null || table.options.onGlobalFilterChange(updater); }; table.resetGlobalFilter = (defaultState) => { table.setGlobalFilter(defaultState ? void 0 : table.initialState.globalFilter); }; } }; var RowExpanding = { getInitialState: (state) => { return { expanded: {}, ...state }; }, getDefaultOptions: (table) => { return { onExpandedChange: makeStateUpdater("expanded", table), paginateExpandedRows: true }; }, createTable: (table) => { let registered = false; let queued = false; table._autoResetExpanded = () => { var _ref, _table$options$autoRe; if (!registered) { table._queue(() => { registered = true; }); return; } if ((_ref = (_table$options$autoRe = table.options.autoResetAll) != null ? _table$options$autoRe : table.options.autoResetExpanded) != null ? _ref : !table.options.manualExpanding) { if (queued) return; queued = true; table._queue(() => { table.resetExpanded(); queued = false; }); } }; table.setExpanded = (updater) => table.options.onExpandedChange == null ? void 0 : table.options.onExpandedChange(updater); table.toggleAllRowsExpanded = (expanded) => { if (expanded != null ? expanded : !table.getIsAllRowsExpanded()) { table.setExpanded(true); } else { table.setExpanded({}); } }; table.resetExpanded = (defaultState) => { var _table$initialState$e, _table$initialState; table.setExpanded(defaultState ? {} : (_table$initialState$e = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.expanded) != null ? _table$initialState$e : {}); }; table.getCanSomeRowsExpand = () => { return table.getPrePaginationRowModel().flatRows.some((row) => row.getCanExpand()); }; table.getToggleAllRowsExpandedHandler = () => { return (e) => { e.persist == null || e.persist(); table.toggleAllRowsExpanded(); }; }; table.getIsSomeRowsExpanded = () => { const expanded = table.getState().expanded; return expanded === true || Object.values(expanded).some(Boolean); }; table.getIsAllRowsExpanded = () => { const expanded = table.getState().expanded; if (typeof expanded === "boolean") { return expanded === true; } if (!Object.keys(expanded).length) { return false; } if (table.getRowModel().flatRows.some((row) => !row.getIsExpanded())) { return false; } return true; }; table.getExpandedDepth = () => { let maxDepth = 0; const rowIds = table.getState().expanded === true ? Object.keys(table.getRowModel().rowsById) : Object.keys(table.getState().expanded); rowIds.forEach((id) => { const splitId = id.split("."); maxDepth = Math.max(maxDepth, splitId.length); }); return maxDepth; }; table.getPreExpandedRowModel = () => table.getSortedRowModel(); table.getExpandedRowModel = () => { if (!table._getExpandedRowModel && table.options.getExpandedRowModel) { table._getExpandedRowModel = table.options.getExpandedRowModel(table); } if (table.options.manualExpanding || !table._getExpandedRowModel) { return table.getPreExpandedRowModel(); } return table._getExpandedRowModel(); }; }, createRow: (row, table) => { row.toggleExpanded = (expanded) => { table.setExpanded((old) => { var _expanded; const exists = old === true ? true : !!(old != null && old[row.id]); let oldExpanded = {}; if (old === true) { Object.keys(table.getRowModel().rowsById).forEach((rowId) => { oldExpanded[rowId] = true; }); } else { oldExpanded = old; } expanded = (_expanded = expanded) != null ? _expanded : !exists; if (!exists && expanded) { return { ...oldExpanded, [row.id]: true }; } if (exists && !expanded) { const { [row.id]: _, ...rest } = oldExpanded; return rest; } return old; }); }; row.getIsExpanded = () => { var _table$options$getIsR; const expanded = table.getState().expanded; return !!((_table$options$getIsR = table.options.getIsRowExpanded == null ? void 0 : table.options.getIsRowExpanded(row)) != null ? _table$options$getIsR : expanded === true || (expanded == null ? void 0 : expanded[row.id])); }; row.getCanExpand = () => { var _table$options$getRow, _table$options$enable, _row$subRows; return (_table$options$getRow = table.options.getRowCanExpand == null ? void 0 : table.options.getRowCanExpand(row)) != null ? _table$options$getRow : ((_table$options$enable = table.options.enableExpanding) != null ? _table$options$enable : true) && !!((_row$subRows = row.subRows) != null && _row$subRows.length); }; row.getIsAllParentsExpanded = () => { let isFullyExpanded = true; let currentRow = row; while (isFullyExpanded && currentRow.parentId) { currentRow = table.getRow(currentRow.parentId, true); isFullyExpanded = currentRow.getIsExpanded(); } return isFullyExpanded; }; row.getToggleExpandedHandler = () => { const canExpand = row.getCanExpand(); return () => { if (!canExpand) return; row.toggleExpanded(); }; }; } }; var defaultPageIndex = 0; var defaultPageSize = 10; var getDefaultPaginationState = () => ({ pageIndex: defaultPageIndex, pageSize: defaultPageSize }); var RowPagination = { getInitialState: (state) => { return { ...state, pagination: { ...getDefaultPaginationState(), ...state == null ? void 0 : state.pagination } }; }, getDefaultOptions: (table) => { return { onPaginationChange: makeStateUpdater("pagination", table) }; }, createTable: (table) => { let registered = false; let queued = false; table._autoResetPageIndex = () => { var _ref, _table$options$autoRe; if (!registered) { table._queue(() => { registered = true; }); return; } if ((_ref = (_table$options$autoRe = table.options.autoResetAll) != null ? _table$options$autoRe : table.options.autoResetPageIndex) != null ? _ref : !table.options.manualPagination) { if (queued) return; queued = true; table._queue(() => { table.resetPageIndex(); queued = false; }); } }; table.setPagination = (updater) => { const safeUpdater = (old) => { let newState = functionalUpdate2(updater, old); return newState; }; return table.options.onPaginationChange == null ? void 0 : table.options.onPaginationChange(safeUpdater); }; table.resetPagination = (defaultState) => { var _table$initialState$p; table.setPagination(defaultState ? getDefaultPaginationState() : (_table$initialState$p = table.initialState.pagination) != null ? _table$initialState$p : getDefaultPaginationState()); }; table.setPageIndex = (updater) => { table.setPagination((old) => { let pageIndex = functionalUpdate2(updater, old.pageIndex); const maxPageIndex = typeof table.options.pageCount === "undefined" || table.options.pageCount === -1 ? Number.MAX_SAFE_INTEGER : table.options.pageCount - 1; pageIndex = Math.max(0, Math.min(pageIndex, maxPageIndex)); return { ...old, pageIndex }; }); }; table.resetPageIndex = (defaultState) => { var _table$initialState$p2, _table$initialState; table.setPageIndex(defaultState ? defaultPageIndex : (_table$initialState$p2 = (_table$initialState = table.initialState) == null || (_table$initialState = _table$initialState.pagination) == null ? void 0 : _table$initialState.pageIndex) != null ? _table$initialState$p2 : defaultPageIndex); }; table.resetPageSize = (defaultState) => { var _table$initialState$p3, _table$initialState2; table.setPageSize(defaultState ? defaultPageSize : (_table$initialState$p3 = (_table$initialState2 = table.initialState) == null || (_table$initialState2 = _table$initialState2.pagination) == null ? void 0 : _table$initialState2.pageSize) != null ? _table$initialState$p3 : defaultPageSize); }; table.setPageSize = (updater) => { table.setPagination((old) => { const pageSize = Math.max(1, functionalUpdate2(updater, old.pageSize)); const topRowIndex = old.pageSize * old.pageIndex; const pageIndex = Math.floor(topRowIndex / pageSize); return { ...old, pageIndex, pageSize }; }); }; table.setPageCount = (updater) => table.setPagination((old) => { var _table$options$pageCo; let newPageCount = functionalUpdate2(updater, (_table$options$pageCo = table.options.pageCount) != null ? _table$options$pageCo : -1); if (typeof newPageCount === "number") { newPageCount = Math.max(-1, newPageCount); } return { ...old, pageCount: newPageCount }; }); table.getPageOptions = memo(() => [table.getPageCount()], (pageCount) => { let pageOptions = []; if (pageCount && pageCount > 0) { pageOptions = [...new Array(pageCount)].fill(null).map((_, i) => i); } return pageOptions; }, getMemoOptions(table.options, "debugTable", "getPageOptions")); table.getCanPreviousPage = () => table.getState().pagination.pageIndex > 0; table.getCanNextPage = () => { const { pageIndex } = table.getState().pagination; const pageCount = table.getPageCount(); if (pageCount === -1) { return true; } if (pageCount === 0) { return false; } return pageIndex < pageCount - 1; }; table.previousPage = () => { return table.setPageIndex((old) => old - 1); }; table.nextPage = () => { return table.setPageIndex((old) => { return old + 1; }); }; table.firstPage = () => { return table.setPageIndex(0); }; table.lastPage = () => { return table.setPageIndex(table.getPageCount() - 1); }; table.getPrePaginationRowModel = () => table.getExpandedRowModel(); table.getPaginationRowModel = () => { if (!table._getPaginationRowModel && table.options.getPaginationRowModel) { table._getPaginationRowModel = table.options.getPaginationRowModel(table); } if (table.options.manualPagination || !table._getPaginationRowModel) { return table.getPrePaginationRowModel(); } return table._getPaginationRowModel(); }; table.getPageCount = () => { var _table$options$pageCo2; return (_table$options$pageCo2 = table.options.pageCount) != null ? _table$options$pageCo2 : Math.ceil(table.getRowCount() / table.getState().pagination.pageSize); }; table.getRowCount = () => { var _table$options$rowCou; return (_table$options$rowCou = table.options.rowCount) != null ? _table$options$rowCou : table.getPrePaginationRowModel().rows.length; }; } }; var getDefaultRowPinningState = () => ({ top: [], bottom: [] }); var RowPinning = { getInitialState: (state) => { return { rowPinning: getDefaultRowPinningState(), ...state }; }, getDefaultOptions: (table) => { return { onRowPinningChange: makeStateUpdater("rowPinning", table) }; }, createRow: (row, table) => { row.pin = (position, includeLeafRows, includeParentRows) => { const leafRowIds = includeLeafRows ? row.getLeafRows().map((_ref) => { let { id } = _ref; return id; }) : []; const parentRowIds = includeParentRows ? row.getParentRows().map((_ref2) => { let { id } = _ref2; return id; }) : []; const rowIds = /* @__PURE__ */ new Set([...parentRowIds, row.id, ...leafRowIds]); table.setRowPinning((old) => { var _old$top3, _old$bottom3; if (position === "bottom") { var _old$top, _old$bottom; return { top: ((_old$top = old == null ? void 0 : old.top) != null ? _old$top : []).filter((d) => !(rowIds != null && rowIds.has(d))), bottom: [...((_old$bottom = old == null ? void 0 : old.bottom) != null ? _old$bottom : []).filter((d) => !(rowIds != null && rowIds.has(d))), ...Array.from(rowIds)] }; } if (position === "top") { var _old$top2, _old$bottom2; return { top: [...((_old$top2 = old == null ? void 0 : old.top) != null ? _old$top2 : []).filter((d) => !(rowIds != null && rowIds.has(d))), ...Array.from(rowIds)], bottom: ((_old$bottom2 = old == null ? void 0 : old.bottom) != null ? _old$bottom2 : []).filter((d) => !(rowIds != null && rowIds.has(d))) }; } return { top: ((_old$top3 = old == null ? void 0 : old.top) != null ? _old$top3 : []).filter((d) => !(rowIds != null && rowIds.has(d))), bottom: ((_old$bottom3 = old == null ? void 0 : old.bottom) != null ? _old$bottom3 : []).filter((d) => !(rowIds != null && rowIds.has(d))) }; }); }; row.getCanPin = () => { var _ref3; const { enableRowPinning, enablePinning } = table.options; if (typeof enableRowPinning === "function") { return enableRowPinning(row); } return (_ref3 = enableRowPinning != null ? enableRowPinning : enablePinning) != null ? _ref3 : true; }; row.getIsPinned = () => { const rowIds = [row.id]; const { top, bottom } = table.getState().rowPinning; const isTop = rowIds.some((d) => top == null ? void 0 : top.includes(d)); const isBottom = rowIds.some((d) => bottom == null ? void 0 : bottom.includes(d)); return isTop ? "top" : isBottom ? "bottom" : false; }; row.getPinnedIndex = () => { var _ref4, _visiblePinnedRowIds$; const position = row.getIsPinned(); if (!position) return -1; const visiblePinnedRowIds = (_ref4 = position === "top" ? table.getTopRows() : table.getBottomRows()) == null ? void 0 : _ref4.map((_ref5) => { let { id } = _ref5; return id; }); return (_visiblePinnedRowIds$ = visiblePinnedRowIds == null ? void 0 : visiblePinnedRowIds.indexOf(row.id)) != null ? _visiblePinnedRowIds$ : -1; }; }, createTable: (table) => { table.setRowPinning = (updater) => table.options.onRowPinningChange == null ? void 0 : table.options.onRowPinningChange(updater); table.resetRowPinning = (defaultState) => { var _table$initialState$r, _table$initialState; return table.setRowPinning(defaultState ? getDefaultRowPinningState() : (_table$initialState$r = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.rowPinning) != null ? _table$initialState$r : getDefaultRowPinningState()); }; table.getIsSomeRowsPinned = (position) => { var _pinningState$positio; const pinningState = table.getState().rowPinning; if (!position) { var _pinningState$top, _pinningState$bottom; return Boolean(((_pinningState$top = pinningState.top) == null ? void 0 : _pinningState$top.length) || ((_pinningState$bottom = pinningState.bottom) == null ? void 0 : _pinningState$bottom.length)); } return Boolean((_pinningState$positio = pinningState[position]) == null ? void 0 : _pinningState$positio.length); }; table._getPinnedRows = (visibleRows, pinnedRowIds, position) => { var _table$options$keepPi; const rows = ((_table$options$keepPi = table.options.keepPinnedRows) != null ? _table$options$keepPi : true) ? ( //get all rows that are pinned even if they would not be otherwise visible //account for expanded parent rows, but not pagination or filtering (pinnedRowIds != null ? pinnedRowIds : []).map((rowId) => { const row = table.getRow(rowId, true); return row.getIsAllParentsExpanded() ? row : null; }) ) : ( //else get only visible rows that are pinned (pinnedRowIds != null ? pinnedRowIds : []).map((rowId) => visibleRows.find((row) => row.id === rowId)) ); return rows.filter(Boolean).map((d) => ({ ...d, position })); }; table.getTopRows = memo(() => [table.getRowModel().rows, table.getState().rowPinning.top], (allRows, topPinnedRowIds) => table._getPinnedRows(allRows, topPinnedRowIds, "top"), getMemoOptions(table.options, "debugRows", "getTopRows")); table.getBottomRows = memo(() => [table.getRowModel().rows, table.getState().rowPinning.bottom], (allRows, bottomPinnedRowIds) => table._getPinnedRows(allRows, bottomPinnedRowIds, "bottom"), getMemoOptions(table.options, "debugRows", "getBottomRows")); table.getCenterRows = memo(() => [table.getRowModel().rows, table.getState().rowPinning.top, table.getState().rowPinning.bottom], (allRows, top, bottom) => { const topAndBottom = /* @__PURE__ */ new Set([...top != null ? top : [], ...bottom != null ? bottom : []]); return allRows.filter((d) => !topAndBottom.has(d.id)); }, getMemoOptions(table.options, "debugRows", "getCenterRows")); } }; var RowSelection = { getInitialState: (state) => { return { rowSelection: {}, ...state }; }, getDefaultOptions: (table) => { return { onRowSelectionChange: makeStateUpdater("rowSelection", table), enableRowSelection: true, enableMultiRowSelection: true, enableSubRowSelection: true // enableGroupingRowSelection: false, // isAdditiveSelectEvent: (e: unknown) => !!e.metaKey, // isInclusiveSelectEvent: (e: unknown) => !!e.shiftKey, }; }, createTable: (table) => { table.setRowSelection = (updater) => table.options.onRowSelectionChange == null ? void 0 : table.options.onRowSelectionChange(updater); table.resetRowSelection = (defaultState) => { var _table$initialState$r; return table.setRowSelection(defaultState ? {} : (_table$initialState$r = table.initialState.rowSelection) != null ? _table$initialState$r : {}); }; table.toggleAllRowsSelected = (value) => { table.setRowSelection((old) => { value = typeof value !== "undefined" ? value : !table.getIsAllRowsSelected(); const rowSelection = { ...old }; const preGroupedFlatRows = table.getPreGroupedRowModel().flatRows; if (value) { preGroupedFlatRows.forEach((row) => { if (!row.getCanSelect()) { return; } rowSelection[row.id] = true; }); } else { preGroupedFlatRows.forEach((row) => { delete rowSelection[row.id]; }); } return rowSelection; }); }; table.toggleAllPageRowsSelected = (value) => table.setRowSelection((old) => { const resolvedValue = typeof value !== "undefined" ? value : !table.getIsAllPageRowsSelected(); const rowSelection = { ...old }; table.getRowModel().rows.forEach((row) => { mutateRowIsSelected(rowSelection, row.id, resolvedValue, true, table); }); return rowSelection; }); table.getPreSelectedRowModel = () => table.getCoreRowModel(); table.getSelectedRowModel = memo(() => [table.getState().rowSelection, table.getCoreRowModel()], (rowSelection, rowModel) => { if (!Object.keys(rowSelection).length) { return { rows: [], flatRows: [], rowsById: {} }; } return selectRowsFn(table, rowModel); }, getMemoOptions(table.options, "debugTable", "getSelectedRowModel")); table.getFilteredSelectedRowModel = memo(() => [table.getState().rowSelection, table.getFilteredRowModel()], (rowSelection, rowModel) => { if (!Object.keys(rowSelection).length) { return { rows: [], flatRows: [], rowsById: {} }; } return selectRowsFn(table, rowModel); }, getMemoOptions(table.options, "debugTable", "getFilteredSelectedRowModel")); table.getGroupedSelectedRowModel = memo(() => [table.getState().rowSelection, table.getSortedRowModel()], (rowSelection, rowModel) => { if (!Object.keys(rowSelection).length) { return { rows: [], flatRows: [], rowsById: {} }; } return selectRowsFn(table, rowModel); }, getMemoOptions(table.options, "debugTable", "getGroupedSelectedRowModel")); table.getIsAllRowsSelected = () => { const preGroupedFlatRows = table.getFilteredRowModel().flatRows; const { rowSelection } = table.getState(); let isAllRowsSelected = Boolean(preGroupedFlatRows.length && Object.keys(rowSelection).length); if (isAllRowsSelected) { if (preGroupedFlatRows.some((row) => row.getCanSelect() && !rowSelection[row.id])) { isAllRowsSelected = false; } } return isAllRowsSelected; }; table.getIsAllPageRowsSelected = () => { const paginationFlatRows = table.getPaginationRowModel().flatRows.filter((row) => row.getCanSelect()); const { rowSelection } = table.getState(); let isAllPageRowsSelected = !!paginationFlatRows.length; if (isAllPageRowsSelected && paginationFlatRows.some((row) => !rowSelection[row.id])) { isAllPageRowsSelected = false; } return isAllPageRowsSelected; }; table.getIsSomeRowsSelected = () => { var _table$getState$rowSe; const totalSelected = Object.keys((_table$getState$rowSe = table.getState().rowSelection) != null ? _table$getState$rowSe : {}).length; return totalSelected > 0 && totalSelected < table.getFilteredRowModel().flatRows.length; }; table.getIsSomePageRowsSelected = () => { const paginationFlatRows = table.getPaginationRowModel().flatRows; return table.getIsAllPageRowsSelected() ? false : paginationFlatRows.filter((row) => row.getCanSelect()).some((d) => d.getIsSelected() || d.getIsSomeSelected()); }; table.getToggleAllRowsSelectedHandler = () => { return (e) => { table.toggleAllRowsSelected(e.target.checked); }; }; table.getToggleAllPageRowsSelectedHandler = () => { return (e) => { table.toggleAllPageRowsSelected(e.target.checked); }; }; }, createRow: (row, table) => { row.toggleSelected = (value, opts) => { const isSelected = row.getIsSelected(); table.setRowSelection((old) => { var _opts$selectChildren; value = typeof value !== "undefined" ? value : !isSelected; if (row.getCanSelect() && isSelected === value) { return old; } const selectedRowIds = { ...old }; mutateRowIsSelected(selectedRowIds, row.id, value, (_opts$selectChildren = opts == null ? void 0 : opts.selectChildren) != null ? _opts$selectChildren : true, table); return selectedRowIds; }); }; row.getIsSelected = () => { const { rowSelection } = table.getState(); return isRowSelected(row, rowSelection); }; row.getIsSomeSelected = () => { const { rowSelection } = table.getState(); return isSubRowSelected(row, rowSelection) === "some"; }; row.getIsAllSubRowsSelected = () => { const { rowSelection } = table.getState(); return isSubRowSelected(row, rowSelection) === "all"; }; row.getCanSelect = () => { var _table$options$enable; if (typeof table.options.enableRowSelection === "function") { return table.options.enableRowSelection(row); } return (_table$options$enable = table.options.enableRowSelection) != null ? _table$options$enable : true; }; row.getCanSelectSubRows = () => { var _table$options$enable2; if (typeof table.options.enableSubRowSelection === "function") { return table.options.enableSubRowSelection(row); } return (_table$options$enable2 = table.options.enableSubRowSelection) != null ? _table$options$enable2 : true; }; row.getCanMultiSelect = () => { var _table$options$enable3; if (typeof table.options.enableMultiRowSelection === "function") { return table.options.enableMultiRowSelection(row); } return (_table$options$enable3 = table.options.enableMultiRowSelection) != null ? _table$options$enable3 : true; }; row.getToggleSelectedHandler = () => { const canSelect = row.getCanSelect(); return (e) => { var _target; if (!canSelect) return; row.toggleSelected((_target = e.target) == null ? void 0 : _target.checked); }; }; } }; var mutateRowIsSelected = (selectedRowIds, id, value, includeChildren, table) => { var _row$subRows; const row = table.getRow(id, true); if (value) { if (!row.getCanMultiSelect()) { Object.keys(selectedRowIds).forEach((key) => delete selectedRowIds[key]); } if (row.getCanSelect()) { selectedRowIds[id] = true; } } else { delete selectedRowIds[id]; } if (includeChildren && (_row$subRows = row.subRows) != null && _row$subRows.length && row.getCanSelectSubRows()) { row.subRows.forEach((row2) => mutateRowIsSelected(selectedRowIds, row2.id, value, includeChildren, table)); } }; function selectRowsFn(table, rowModel) { const rowSelection = table.getState().rowSelection; const newSelectedFlatRows = []; const newSelectedRowsById = {}; const recurseRows = function(rows, depth) { return rows.map((row) => { var _row$subRows2; const isSelected = isRowSelected(row, rowSelection); if (isSelected) { newSelectedFlatRows.push(row); newSelectedRowsById[row.id] = row; } if ((_row$subRows2 = row.subRows) != null && _row$subRows2.length) { row = { ...row, subRows: recurseRows(row.subRows) }; } if (isSelected) { return row; } }).filter(Boolean); }; return { rows: recurseRows(rowModel.rows), flatRows: newSelectedFlatRows, rowsById: newSelectedRowsById }; } function isRowSelected(row, selection) { var _selection$row$id; return (_selection$row$id = selection[row.id]) != null ? _selection$row$id : false; } function isSubRowSelected(row, selection, table) { var _row$subRows3; if (!((_row$subRows3 = row.subRows) != null && _row$subRows3.length)) return false; let allChildrenSelected = true; let someSelected = false; row.subRows.forEach((subRow) => { if (someSelected && !allChildrenSelected) { return; } if (subRow.getCanSelect()) { if (isRowSelected(subRow, selection)) { someSelected = true; } else { allChildrenSelected = false; } } if (subRow.subRows && subRow.subRows.length) { const subRowChildrenSelected = isSubRowSelected(subRow, selection); if (subRowChildrenSelected === "all") { someSelected = true; } else if (subRowChildrenSelected === "some") { someSelected = true; allChildrenSelected = false; } else { allChildrenSelected = false; } } }); return allChildrenSelected ? "all" : someSelected ? "some" : false; } var reSplitAlphaNumeric = /([0-9]+)/gm; var alphanumeric = (rowA, rowB, columnId) => { return compareAlphanumeric(toString(rowA.getValue(columnId)).toLowerCase(), toString(rowB.getValue(columnId)).toLowerCase()); }; var alphanumericCaseSensitive = (rowA, rowB, columnId) => { return compareAlphanumeric(toString(rowA.getValue(columnId)), toString(rowB.getValue(columnId))); }; var text = (rowA, rowB, columnId) => { return compareBasic(toString(rowA.getValue(columnId)).toLowerCase(), toString(rowB.getValue(columnId)).toLowerCase()); }; var textCaseSensitive = (rowA, rowB, columnId) => { return compareBasic(toString(rowA.getValue(columnId)), toString(rowB.getValue(columnId))); }; var datetime = (rowA, rowB, columnId) => { const a = rowA.getValue(columnId); const b = rowB.getValue(columnId); return a > b ? 1 : a < b ? -1 : 0; }; var basic = (rowA, rowB, columnId) => { return compareBasic(rowA.getValue(columnId), rowB.getValue(columnId)); }; function compareBasic(a, b) { return a === b ? 0 : a > b ? 1 : -1; } function toString(a) { if (typeof a === "number") { if (isNaN(a) || a === Infinity || a === -Infinity) { return ""; } return String(a); } if (typeof a === "string") { return a; } return ""; } function compareAlphanumeric(aStr, bStr) { const a = aStr.split(reSplitAlphaNumeric).filter(Boolean); const b = bStr.split(reSplitAlphaNumeric).filter(Boolean); while (a.length && b.length) { const aa = a.shift(); const bb = b.shift(); const an = parseInt(aa, 10); const bn = parseInt(bb, 10); const combo = [an, bn].sort(); if (isNaN(combo[0])) { if (aa > bb) { return 1; } if (bb > aa) { return -1; } continue; } if (isNaN(combo[1])) { return isNaN(an) ? -1 : 1; } if (an > bn) { return 1; } if (bn > an) { return -1; } } return a.length - b.length; } var sortingFns = { alphanumeric, alphanumericCaseSensitive, text, textCaseSensitive, datetime, basic }; var RowSorting = { getInitialState: (state) => { return { sorting: [], ...state }; }, getDefaultColumnDef: () => { return { sortingFn: "auto", sortUndefined: 1 }; }, getDefaultOptions: (table) => { return { onSortingChange: makeStateUpdater("sorting", table), isMultiSortEvent: (e) => { return e.shiftKey; } }; }, createColumn: (column, table) => { column.getAutoSortingFn = () => { const firstRows = table.getFilteredRowModel().flatRows.slice(10); let isString = false; for (const row of firstRows) { const value = row == null ? void 0 : row.getValue(column.id); if (Object.prototype.toString.call(value) === "[object Date]") { return sortingFns.datetime; } if (typeof value === "string") { isString = true; if (value.split(reSplitAlphaNumeric).length > 1) { return sortingFns.alphanumeric; } } } if (isString) { return sortingFns.text; } return sortingFns.basic; }; column.getAutoSortDir = () => { const firstRow = table.getFilteredRowModel().flatRows[0]; const value = firstRow == null ? void 0 : firstRow.getValue(column.id); if (typeof value === "string") { return "asc"; } return "desc"; }; column.getSortingFn = () => { var _table$options$sortin, _table$options$sortin2; if (!column) { throw new Error(); } return isFunction(column.columnDef.sortingFn) ? column.columnDef.sortingFn : column.columnDef.sortingFn === "auto" ? column.getAutoSortingFn() : (_table$options$sortin = (_table$options$sortin2 = table.options.sortingFns) == null ? void 0 : _table$options$sortin2[column.columnDef.sortingFn]) != null ? _table$options$sortin : sortingFns[column.columnDef.sortingFn]; }; column.toggleSorting = (desc, multi) => { const nextSortingOrder = column.getNextSortingOrder(); const hasManualValue = typeof desc !== "undefined" && desc !== null; table.setSorting((old) => { const existingSorting = old == null ? void 0 : old.find((d) => d.id === column.id); const existingIndex = old == null ? void 0 : old.findIndex((d) => d.id === column.id); let newSorting = []; let sortAction; let nextDesc = hasManualValue ? desc : nextSortingOrder === "desc"; if (old != null && old.length && column.getCanMultiSort() && multi) { if (existingSorting) { sortAction = "toggle"; } else { sortAction = "add"; } } else { if (old != null && old.length && existingIndex !== old.length - 1) { sortAction = "replace"; } else if (existingSorting) { sortAction = "toggle"; } else { sortAction = "replace"; } } if (sortAction === "toggle") { if (!hasManualValue) { if (!nextSortingOrder) { sortAction = "remove"; } } } if (sortAction === "add") { var _table$options$maxMul; newSorting = [...old, { id: column.id, desc: nextDesc }]; newSorting.splice(0, newSorting.length - ((_table$options$maxMul = table.options.maxMultiSortColCount) != null ? _table$options$maxMul : Number.MAX_SAFE_INTEGER)); } else if (sortAction === "toggle") { newSorting = old.map((d) => { if (d.id === column.id) { return { ...d, desc: nextDesc }; } return d; }); } else if (sortAction === "remove") { newSorting = old.filter((d) => d.id !== column.id); } else { newSorting = [{ id: column.id, desc: nextDesc }]; } return newSorting; }); }; column.getFirstSortDir = () => { var _ref, _column$columnDef$sor; const sortDescFirst = (_ref = (_column$columnDef$sor = column.columnDef.sortDescFirst) != null ? _column$columnDef$sor : table.options.sortDescFirst) != null ? _ref : column.getAutoSortDir() === "desc"; return sortDescFirst ? "desc" : "asc"; }; column.getNextSortingOrder = (multi) => { var _table$options$enable, _table$options$enable2; const firstSortDirection = column.getFirstSortDir(); const isSorted = column.getIsSorted(); if (!isSorted) { return firstSortDirection; } if (isSorted !== firstSortDirection && ((_table$options$enable = table.options.enableSortingRemoval) != null ? _table$options$enable : true) && // If enableSortRemove, enable in general (multi ? (_table$options$enable2 = table.options.enableMultiRemove) != null ? _table$options$enable2 : true : true)) { return false; } return isSorted === "desc" ? "asc" : "desc"; }; column.getCanSort = () => { var _column$columnDef$ena, _table$options$enable3; return ((_column$columnDef$ena = column.columnDef.enableSorting) != null ? _column$columnDef$ena : true) && ((_table$options$enable3 = table.options.enableSorting) != null ? _table$options$enable3 : true) && !!column.accessorFn; }; column.getCanMultiSort = () => { var _ref2, _column$columnDef$ena2; return (_ref2 = (_column$columnDef$ena2 = column.columnDef.enableMultiSort) != null ? _column$columnDef$ena2 : table.options.enableMultiSort) != null ? _ref2 : !!column.accessorFn; }; column.getIsSorted = () => { var _table$getState$sorti; const columnSort = (_table$getState$sorti = table.getState().sorting) == null ? void 0 : _table$getState$sorti.find((d) => d.id === column.id); return !columnSort ? false : columnSort.desc ? "desc" : "asc"; }; column.getSortIndex = () => { var _table$getState$sorti2, _table$getState$sorti3; return (_table$getState$sorti2 = (_table$getState$sorti3 = table.getState().sorting) == null ? void 0 : _table$getState$sorti3.findIndex((d) => d.id === column.id)) != null ? _table$getState$sorti2 : -1; }; column.clearSorting = () => { table.setSorting((old) => old != null && old.length ? old.filter((d) => d.id !== column.id) : []); }; column.getToggleSortingHandler = () => { const canSort = column.getCanSort(); return (e) => { if (!canSort) return; e.persist == null || e.persist(); column.toggleSorting == null || column.toggleSorting(void 0, column.getCanMultiSort() ? table.options.isMultiSortEvent == null ? void 0 : table.options.isMultiSortEvent(e) : false); }; }; }, createTable: (table) => { table.setSorting = (updater) => table.options.onSortingChange == null ? void 0 : table.options.onSortingChange(updater); table.resetSorting = (defaultState) => { var _table$initialState$s, _table$initialState; table.setSorting(defaultState ? [] : (_table$initialState$s = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.sorting) != null ? _table$initialState$s : []); }; table.getPreSortedRowModel = () => table.getGroupedRowModel(); table.getSortedRowModel = () => { if (!table._getSortedRowModel && table.options.getSortedRowModel) { table._getSortedRowModel = table.options.getSortedRowModel(table); } if (table.options.manualSorting || !table._getSortedRowModel) { return table.getPreSortedRowModel(); } return table._getSortedRowModel(); }; } }; var builtInFeatures = [ Headers2, ColumnVisibility, ColumnOrdering, ColumnPinning, ColumnFaceting, ColumnFiltering, GlobalFaceting, //depends on ColumnFaceting GlobalFiltering, //depends on ColumnFiltering RowSorting, ColumnGrouping, //depends on RowSorting RowExpanding, RowPagination, RowPinning, RowSelection, ColumnSizing ]; function createTable(options) { var _options$_features, _options$initialState; if (false) { console.info("Creating Table Instance..."); } const _features = [...builtInFeatures, ...(_options$_features = options._features) != null ? _options$_features : []]; let table = { _features }; const defaultOptions = table._features.reduce((obj, feature) => { return Object.assign(obj, feature.getDefaultOptions == null ? void 0 : feature.getDefaultOptions(table)); }, {}); const mergeOptions = (options2) => { if (table.options.mergeOptions) { return table.options.mergeOptions(defaultOptions, options2); } return { ...defaultOptions, ...options2 }; }; const coreInitialState = {}; let initialState = { ...coreInitialState, ...(_options$initialState = options.initialState) != null ? _options$initialState : {} }; table._features.forEach((feature) => { var _feature$getInitialSt; initialState = (_feature$getInitialSt = feature.getInitialState == null ? void 0 : feature.getInitialState(initialState)) != null ? _feature$getInitialSt : initialState; }); const queued = []; let queuedTimeout = false; const coreInstance = { _features, options: { ...defaultOptions, ...options }, initialState, _queue: (cb) => { queued.push(cb); if (!queuedTimeout) { queuedTimeout = true; Promise.resolve().then(() => { while (queued.length) { queued.shift()(); } queuedTimeout = false; }).catch((error) => setTimeout(() => { throw error; })); } }, reset: () => { table.setState(table.initialState); }, setOptions: (updater) => { const newOptions = functionalUpdate2(updater, table.options); table.options = mergeOptions(newOptions); }, getState: () => { return table.options.state; }, setState: (updater) => { table.options.onStateChange == null || table.options.onStateChange(updater); }, _getRowId: (row, index, parent) => { var _table$options$getRow; return (_table$options$getRow = table.options.getRowId == null ? void 0 : table.options.getRowId(row, index, parent)) != null ? _table$options$getRow : `${parent ? [parent.id, index].join(".") : index}`; }, getCoreRowModel: () => { if (!table._getCoreRowModel) { table._getCoreRowModel = table.options.getCoreRowModel(table); } return table._getCoreRowModel(); }, // The final calls start at the bottom of the model, // expanded rows, which then work their way up getRowModel: () => { return table.getPaginationRowModel(); }, //in next version, we should just pass in the row model as the optional 2nd arg getRow: (id, searchAll) => { let row = (searchAll ? table.getPrePaginationRowModel() : table.getRowModel()).rowsById[id]; if (!row) { row = table.getCoreRowModel().rowsById[id]; if (!row) { if (false) { throw new Error(`getRow could not find row with ID: ${id}`); } throw new Error(); } } return row; }, _getDefaultColumnDef: memo(() => [table.options.defaultColumn], (defaultColumn) => { var _defaultColumn; defaultColumn = (_defaultColumn = defaultColumn) != null ? _defaultColumn : {}; return { header: (props) => { const resolvedColumnDef = props.header.column.columnDef; if (resolvedColumnDef.accessorKey) { return resolvedColumnDef.accessorKey; } if (resolvedColumnDef.accessorFn) { return resolvedColumnDef.id; } return null; }, // footer: props => props.header.column.id, cell: (props) => { var _props$renderValue$to, _props$renderValue; return (_props$renderValue$to = (_props$renderValue = props.renderValue()) == null || _props$renderValue.toString == null ? void 0 : _props$renderValue.toString()) != null ? _props$renderValue$to : null; }, ...table._features.reduce((obj, feature) => { return Object.assign(obj, feature.getDefaultColumnDef == null ? void 0 : feature.getDefaultColumnDef()); }, {}), ...defaultColumn }; }, getMemoOptions(options, "debugColumns", "_getDefaultColumnDef")), _getColumnDefs: () => table.options.columns, getAllColumns: memo(() => [table._getColumnDefs()], (columnDefs) => { const recurseColumns = function(columnDefs2, parent, depth) { if (depth === void 0) { depth = 0; } return columnDefs2.map((columnDef) => { const column = createColumn(table, columnDef, depth, parent); const groupingColumnDef = columnDef; column.columns = groupingColumnDef.columns ? recurseColumns(groupingColumnDef.columns, column, depth + 1) : []; return column; }); }; return recurseColumns(columnDefs); }, getMemoOptions(options, "debugColumns", "getAllColumns")), getAllFlatColumns: memo(() => [table.getAllColumns()], (allColumns) => { return allColumns.flatMap((column) => { return column.getFlatColumns(); }); }, getMemoOptions(options, "debugColumns", "getAllFlatColumns")), _getAllFlatColumnsById: memo(() => [table.getAllFlatColumns()], (flatColumns) => { return flatColumns.reduce((acc, column) => { acc[column.id] = column; return acc; }, {}); }, getMemoOptions(options, "debugColumns", "getAllFlatColumnsById")), getAllLeafColumns: memo(() => [table.getAllColumns(), table._getOrderColumnsFn()], (allColumns, orderColumns2) => { let leafColumns = allColumns.flatMap((column) => column.getLeafColumns()); return orderColumns2(leafColumns); }, getMemoOptions(options, "debugColumns", "getAllLeafColumns")), getColumn: (columnId) => { const column = table._getAllFlatColumnsById()[columnId]; if (false) { console.error(`[Table] Column with id '${columnId}' does not exist.`); } return column; } }; Object.assign(table, coreInstance); for (let index = 0; index < table._features.length; index++) { const feature = table._features[index]; feature == null || feature.createTable == null || feature.createTable(table); } return table; } function getCoreRowModel() { return (table) => memo(() => [table.options.data], (data) => { const rowModel = { rows: [], flatRows: [], rowsById: {} }; const accessRows = function(originalRows, depth, parentRow) { if (depth === void 0) { depth = 0; } const rows = []; for (let i = 0; i < originalRows.length; i++) { const row = createRow(table, table._getRowId(originalRows[i], i, parentRow), originalRows[i], i, depth, void 0, parentRow == null ? void 0 : parentRow.id); rowModel.flatRows.push(row); rowModel.rowsById[row.id] = row; rows.push(row); if (table.options.getSubRows) { var _row$originalSubRows; row.originalSubRows = table.options.getSubRows(originalRows[i], i); if ((_row$originalSubRows = row.originalSubRows) != null && _row$originalSubRows.length) { row.subRows = accessRows(row.originalSubRows, depth + 1, row); } } } return rows; }; rowModel.rows = accessRows(data); return rowModel; }, getMemoOptions(table.options, "debugTable", "getRowModel", () => table._autoResetPageIndex())); } // ../../../node_modules/@tanstack/react-table/build/lib/index.mjs function flexRender(Comp, props) { return !Comp ? null : isReactComponent(Comp) ? /* @__PURE__ */ React9.createElement(Comp, props) : Comp; } function isReactComponent(component) { return isClassComponent(component) || typeof component === "function" || isExoticComponent(component); } function isClassComponent(component) { return typeof component === "function" && (() => { const proto = Object.getPrototypeOf(component); return proto.prototype && proto.prototype.isReactComponent; })(); } function isExoticComponent(component) { return typeof component === "object" && typeof component.$$typeof === "symbol" && ["react.memo", "react.forward_ref"].includes(component.$$typeof.description); } function useReactTable(options) { const resolvedOptions = { state: {}, // Dummy state onStateChange: () => { }, // noop renderFallbackValue: null, ...options }; const [tableRef] = React9.useState(() => ({ current: createTable(resolvedOptions) })); const [state, setState] = React9.useState(() => tableRef.current.initialState); tableRef.current.setOptions((prev) => ({ ...prev, ...options, state: { ...state, ...options.state }, // Similarly, we'll maintain both our internal state and any user-provided // state. onStateChange: (updater) => { setState(updater); options.onStateChange == null || options.onStateChange(updater); } })); return tableRef.current; } // virtual:/apps/web/src/utils/formatCents.js init_injected_globals(); function formatCents(value) { const cents = Number(value || 0); const dollars = cents / 100; if (Number.isNaN(dollars)) return "-"; return dollars.toLocaleString(void 0, { style: "currency", currency: "USD" }); } // virtual:/apps/web/src/components/Dashboard/JobsTable.jsx function JobsTable({ rows, total, totalPages, page, pageSize, sortBy, sortOrder, updateParams, compact, // NEW: extra display toggles superCompact = false, wrapDesc = false, // NEW: cross-page selection selectedIds, selectAllActive, excludedIds, toggleRow, selectPage, clearSelection, setSelectAllActive, selectedTotal, visibleSelected }) { const textSizeClass = superCompact ? "text-[11px]" : compact ? "text-xs" : "text-sm"; const padYClass = superCompact ? "py-0.5" : compact ? "py-1" : "py-2"; const pageIds = (0, import_react3.useMemo)(() => rows.map((r) => r.id), [rows]); const allOnPageSelected = (0, import_react3.useMemo)(() => { if (rows.length === 0) return false; return rows.every( (r) => selectAllActive ? !excludedIds.has(r.id) : selectedIds.has(r.id) ); }, [rows, selectAllActive, excludedIds, selectedIds]); const handleTogglePage = (checked) => { selectPage(pageIds, checked); }; const selectedFilteredOut = selectedTotal > 0 && visibleSelected < selectedTotal; const download = (blob, filename) => { const url = URL.createObjectURL(blob); const a = document.createElement("a"); a.href = url; a.download = filename; document.body.appendChild(a); a.click(); a.remove(); URL.revokeObjectURL(url); }; const exportSelectedCsv = async () => { try { const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-"); const params = new URLSearchParams(window.location.search); const filters = { q: params.get("q") || "", qField: params.get("qField") || "all", createdFrom: params.get("createdFrom") || "", createdTo: params.get("createdTo") || "", minBudget: params.get("minBudget") || "", maxBudget: params.get("maxBudget") || "", status: params.get("status") || "" }; const payload = selectAllActive ? { selectAll: true, excludedIds: Array.from(excludedIds), filters } : { ids: Array.from(selectedIds) }; const res = await fetch("/api/jobs/export-selected", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(payload) }); if (!res.ok) { throw new Error( `When exporting selected, the response was [${res.status}] ${res.statusText}` ); } const blob = await res.blob(); download(blob, `jobs-selected-${ts}.csv`); } catch (e) { console.error("export selected csv failed", e); alert("Could not export selected rows."); } }; const exportSelectedJson = async () => { try { const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-"); const params = new URLSearchParams(window.location.search); const filters = { q: params.get("q") || "", qField: params.get("qField") || "all", createdFrom: params.get("createdFrom") || "", createdTo: params.get("createdTo") || "", minBudget: params.get("minBudget") || "", maxBudget: params.get("maxBudget") || "", status: params.get("status") || "" }; const payload = selectAllActive ? { selectAll: true, excludedIds: Array.from(excludedIds), filters } : { ids: Array.from(selectedIds) }; const res = await fetch("/api/jobs/export-selected-json", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(payload) }); if (!res.ok) { throw new Error( `When exporting selected JSON, the response was [${res.status}] ${res.statusText}` ); } const blob = await res.blob(); download(blob, `jobs-selected-${ts}.json`); } catch (e) { console.error("export selected json failed", e); alert("Could not export selected rows."); } }; const collectSelectedRows = async ({ selectedIds: selectedIds2, selectAllActive: selectAllActive2, excludedIds: excludedIds2 }) => { const cap = 5e3; if (selectAllActive2) { const params = new URLSearchParams(window.location.search); params.delete("page"); params.delete("pageSize"); params.set("page", "1"); params.set("pageSize", "100"); const out = []; let pageN = 1; let totalPagesLocal = 1; do { params.set("page", String(pageN)); const res = await fetch(`/api/jobs?${params.toString()}`, { cache: "no-store" }); if (!res.ok) throw new Error( `When fetching /api/jobs, the response was [${res.status}] ${res.statusText}` ); const json = await res.json(); const chunk = Array.isArray(json?.jobs) ? json.jobs : []; for (const r of chunk) { if (!excludedIds2.has(r.id)) out.push(r); if (out.length >= cap) break; } totalPagesLocal = json?.pageSize && json?.total ? Math.ceil(json.total / json.pageSize) : json?.totalPages || page; pageN++; } while (pageN <= totalPagesLocal && out.length < cap); return out; } const onPageMap = new Map(rows.map((r) => [r.id, r])); const result = []; for (const id of selectedIds2) { if (onPageMap.has(id)) { result.push(onPageMap.get(id)); } else { try { const r = await fetch(`/api/jobs/${id}`); if (r.ok) { const j = await r.json(); if (j?.job) result.push(j.job); } } catch (e) { console.error("fetch job by id failed", e); } } if (result.length >= cap) break; } return result; }; const columns = (0, import_react3.useMemo)( () => [ // selection column { id: "_select", header: () => /* @__PURE__ */ React.createElement( "input", { type: "checkbox", checked: allOnPageSelected, onChange: (e) => handleTogglePage(e.target.checked), title: "Select all on this page" } ), cell: (info) => { const row = info.row.original; const checked = selectAllActive ? !excludedIds.has(row.id) : selectedIds.has(row.id); return /* @__PURE__ */ React.createElement( "input", { type: "checkbox", checked, onChange: (e) => toggleRow(row.id, e.target.checked), onClick: (e) => e.stopPropagation(), title: checked ? "Unselect" : "Select" } ); } }, { header: "Title", accessorKey: "title", cell: (info) => { const row = info.row.original; const title = String(info.getValue() || "").trim() || "(untitled)"; return /* @__PURE__ */ React.createElement("div", { className: "flex items-center gap-2" }, /* @__PURE__ */ React.createElement( "a", { href: `/jobs/${row.id}`, className: "text-[#9EE7FF] hover:underline", onClick: (e) => e.stopPropagation() }, title ), /* @__PURE__ */ React.createElement( "a", { href: `/jobs/${row.id}`, target: "_blank", rel: "noopener noreferrer", onClick: (e) => e.stopPropagation(), className: "opacity-0 group-hover:opacity-100 transition-opacity text-[11px] text-white/60 hover:text-white", title: "Open in new tab" }, "\u2197" )); } }, { header: "Status", accessorKey: "status" }, { header: "Budget", accessorKey: "budget_cents", cell: (info) => formatCents(info.getValue()) }, { header: "Created", accessorKey: "created_at", cell: (info) => { const v = info.getValue(); if (!v) return "-"; const d = new Date(v); return isNaN(d.getTime()) ? "-" : d.toLocaleDateString(); } }, // Description column with wrap/nowrap toggle support { header: "Description", accessorKey: "description", cell: (info) => { const v = String(info.getValue() || ""); const className = wrapDesc ? "whitespace-normal break-words max-w-[520px]" : "whitespace-nowrap overflow-hidden text-ellipsis max-w-[320px]"; return /* @__PURE__ */ React.createElement("div", { className }, v); } } ], [allOnPageSelected, selectAllActive, excludedIds, selectedIds, wrapDesc] ); const table = useReactTable({ data: rows, columns, manualPagination: true, manualSorting: true, pageCount: totalPages, state: { pagination: { pageIndex: page - 1, pageSize }, sorting: [{ id: sortBy, desc: sortOrder === "desc" }] }, getCoreRowModel: getCoreRowModel() }); const renderHeader = (header) => { const columnId = header.column.id; if (columnId === "_select") { return flexRender(header.column.columnDef.header, header.getContext()); } const isSorted = sortBy === columnId; const arrow = isSorted ? sortOrder === "asc" ? "\u25B2" : "\u25BC" : ""; return /* @__PURE__ */ React.createElement( "button", { className: "flex items-center gap-1 cursor-pointer", onClick: () => { const newOrder = isSorted && sortOrder === "asc" ? "desc" : "asc"; updateParams({ sortBy: columnId, sortOrder: newOrder, page: 1 }); } }, flexRender(header.column.columnDef.header, header.getContext()), /* @__PURE__ */ React.createElement("span", { className: "text-xs opacity-70" }, arrow) ); }; return /* @__PURE__ */ React.createElement(React.Fragment, null, selectedTotal > 0 && /* @__PURE__ */ React.createElement("div", { className: "mb-3 flex items-center justify-between gap-3 text-xs text-white/90" }, /* @__PURE__ */ React.createElement("div", { className: "flex items-center gap-2" }, /* @__PURE__ */ React.createElement("div", null, "Selected ", selectedTotal, " ", selectedTotal === 1 ? "row" : "rows"), selectedFilteredOut && /* @__PURE__ */ React.createElement("span", { className: "px-2 py-1 rounded bg-amber-500/15 text-amber-300" }, visibleSelected, " visible in this view")), /* @__PURE__ */ React.createElement("div", { className: "flex items-center gap-2" }, /* @__PURE__ */ React.createElement( "button", { onClick: () => selectPage(pageIds, true), className: "px-3 py-2 rounded-md bg-white/5 border border-white/10 hover:bg-white/10", title: "Select page" }, "Select page" ), /* @__PURE__ */ React.createElement( "button", { onClick: () => selectPage(pageIds, false), className: "px-3 py-2 rounded-md bg-white/5 border border-white/10 hover:bg-white/10", title: "Deselect page" }, "Deselect page" ), /* @__PURE__ */ React.createElement( "button", { onClick: () => { if (!selectAllActive) { const confirmMsg = total > 5e3 ? `This will select all ${total} results. Exports are capped at 5000 for safety. Continue?` : `Select all ${total} results?`; const ok = window.confirm(confirmMsg); if (!ok) return; } setSelectAllActive(true); }, className: "px-3 py-2 rounded-md bg-white/5 border border-white/10 hover:bg-white/10", title: "Select all across results" }, "Select all results" ), /* @__PURE__ */ React.createElement( "button", { onClick: exportSelectedCsv, className: "px-3 py-2 rounded-md bg-white/5 border border-white/10 hover:bg-white/10" }, "Export selected CSV" ), /* @__PURE__ */ React.createElement( "button", { onClick: exportSelectedJson, className: "px-3 py-2 rounded-md bg-white/5 border border-white/10 hover:bg-white/10" }, "Export selected JSON" ), /* @__PURE__ */ React.createElement( "button", { onClick: clearSelection, className: "px-3 py-2 rounded-md bg-white/5 border border-white/10 hover:bg-white/10" }, "Select none" ))), /* @__PURE__ */ React.createElement("table", { className: `min-w-[900px] w-full text-left ${textSizeClass}` }, /* @__PURE__ */ React.createElement("thead", null, table.getHeaderGroups().map((headerGroup) => /* @__PURE__ */ React.createElement("tr", { key: headerGroup.id, className: "border-b border-white/10" }, headerGroup.headers.map((header) => /* @__PURE__ */ React.createElement( "th", { key: header.id, className: `${padYClass} pr-3 text-white/70 font-medium select-none` }, header.isPlaceholder ? null : renderHeader(header) ))))), /* @__PURE__ */ React.createElement("tbody", null, table.getRowModel().rows.map((row) => /* @__PURE__ */ React.createElement( "tr", { key: row.id, className: `group border-b border-white/5 hover:bg-white/[0.03] cursor-pointer`, onClick: () => { const id = row.original?.id; if (id) window.location.href = `/jobs/${id}`; } }, row.getVisibleCells().map((cell) => /* @__PURE__ */ React.createElement( "td", { key: cell.id, className: `${padYClass} pr-3 text-white/90 align-top` }, flexRender(cell.column.columnDef.cell, cell.getContext()) )) ))))); } // virtual:/apps/web/src/components/Dashboard/SkeletonTable.jsx init_injected_globals(); function SkeletonTable() { return /* @__PURE__ */ React.createElement("table", { className: "min-w-[700px] w-full text-left text-sm" }, /* @__PURE__ */ React.createElement("thead", null, /* @__PURE__ */ React.createElement("tr", { className: "border-b border-white/10" }, ["", "Title", "Status", "Budget", "Created", "Description"].map( (h, i) => /* @__PURE__ */ React.createElement("th", { key: i, className: "py-2 pr-3 text-white/70 font-medium" }, h) ))), /* @__PURE__ */ React.createElement("tbody", null, Array.from({ length: 8 }).map((_, i) => /* @__PURE__ */ React.createElement("tr", { key: i, className: "border-b border-white/5" }, [0, 1, 2, 3, 4, 5].map((c) => /* @__PURE__ */ React.createElement("td", { key: c, className: "py-2 pr-3" }, /* @__PURE__ */ React.createElement("div", { className: "h-4 bg-white/10 rounded w-[80%]" }))))))); } // virtual:/apps/web/src/components/Dashboard/PaginationControls.jsx init_injected_globals(); function PaginationControls({ page, totalPages, total, pageSize, updateParams, compact, superCompact, selectedTotal, visibleSelected }) { const textClass = superCompact ? "text-[11px]" : compact ? "text-xs" : "text-sm"; return /* @__PURE__ */ React.createElement( "div", { className: `flex items-center justify-between gap-3 mt-3 text-white/80 ${textClass}` }, /* @__PURE__ */ React.createElement("div", { className: "flex items-center gap-2" }, /* @__PURE__ */ React.createElement( "button", { onClick: () => updateParams({ page: 1 }), disabled: page === 1, className: "px-2 py-1 rounded bg-white/5 border border-white/10 disabled:opacity-40 disabled:cursor-not-allowed" }, "\xAB First" ), /* @__PURE__ */ React.createElement( "button", { onClick: () => updateParams({ page: page - 1 }), disabled: page === 1, className: "px-2 py-1 rounded bg-white/5 border border-white/10 disabled:opacity-40 disabled:cursor-not-allowed" }, "\u2039 Prev" ), /* @__PURE__ */ React.createElement("span", null, "Page ", page, " of ", totalPages || 1, " (", total, " total)"), /* @__PURE__ */ React.createElement( "button", { onClick: () => updateParams({ page: page + 1 }), disabled: page >= totalPages, className: "px-2 py-1 rounded bg-white/5 border border-white/10 disabled:opacity-40 disabled:cursor-not-allowed" }, "Next \u203A" ), /* @__PURE__ */ React.createElement( "button", { onClick: () => updateParams({ page: totalPages }), disabled: page >= totalPages, className: "px-2 py-1 rounded bg-white/5 border border-white/10 disabled:opacity-40 disabled:cursor-not-allowed" }, "Last \xBB" ), selectedTotal > 0 && /* @__PURE__ */ React.createElement("span", { className: "ml-2 inline-flex items-center gap-2 px-2 py-1 rounded bg-white/5 border border-white/10" }, "Selected: ", visibleSelected, " on page / ", selectedTotal, " total")), /* @__PURE__ */ React.createElement("div", { className: "flex items-center gap-2" }, /* @__PURE__ */ React.createElement("span", null, "Rows per page:"), /* @__PURE__ */ React.createElement( "select", { value: pageSize, onChange: (e) => updateParams({ pageSize: e.target.value, page: 1 }), className: "rounded-md bg-white/5 border border-white/10 px-2 py-1 text-white" }, [10, 20, 30, 50].map((n) => /* @__PURE__ */ React.createElement("option", { key: n, value: n }, n)) )) ); } // virtual:/apps/web/src/app/dashboard/page.jsx var import_meta = {}; function getPublicEnv(key) { try { if (typeof import_meta !== "undefined" && import_meta.env && key in import_meta.env) { return import_meta.env[key]; } } catch (_) { } try { if (typeof process !== "undefined" && process.env && key in process.env) { return process.env[key]; } } catch (_) { } try { if (typeof window !== "undefined" && window.__ENV__ && key in window.__ENV__) { return window.__ENV__[key]; } } catch (_) { } return void 0; } function getMode() { try { if (typeof import_meta !== "undefined" && import_meta.env && import_meta.env.MODE) { return import_meta.env.MODE; } } catch (_) { } try { if (typeof process !== "undefined" && process.env && "production") { return "production"; } } catch (_) { } return "production"; } function resolveSafeMode() { const raw = getPublicEnv("NEXT_PUBLIC_SAFE_MODE"); const val = String(raw || "").toLowerCase(); if (val === "off" || val === "false" || val === "0") return false; if (val === "on" || val === "true" || val === "1") return true; return getMode() === "production"; } function DashboardPage() { const { data: currentUser } = useUser_default(); const isAuthed = !!currentUser?.id; const { data: settings } = useQuery({ queryKey: ["safe-mode-override"], queryFn: async () => { const res = await fetch("/api/admin/settings", { cache: "no-store" }); if (!res.ok) return { safeModeOverride: null }; return res.json().catch(() => ({ safeModeOverride: null })); }, retry: 0, refetchOnWindowFocus: false, staleTime: 5 * 60 * 1e3 }); const { data: isAdminOk } = useQuery({ queryKey: ["is-admin"], queryFn: async () => { const res = await fetch("/api/admin/check"); return res.ok; }, retry: 0, refetchOnWindowFocus: false, staleTime: 5 * 60 * 1e3 }); const envDefault = resolveSafeMode(); const SAFE_MODE = settings?.safeModeOverride === "on" ? true : settings?.safeModeOverride === "off" ? false : envDefault; if (SAFE_MODE && !isAuthed) { return /* @__PURE__ */ import_react4.default.createElement("div", { className: "mx-auto max-w-[1100px] px-6 py-10 text-white" }, isAdminOk ? /* @__PURE__ */ import_react4.default.createElement("div", { className: "flex justify-end mb-3" }, /* @__PURE__ */ import_react4.default.createElement("span", { className: "px-2 py-1 rounded-full text-[11px] border bg-white/10 text-white" }, "Safe: ", SAFE_MODE ? "ON" : "OFF", " (env:", envDefault ? "on" : "off", ", override:", String(settings?.safeModeOverride ?? "null"), ")")) : null, /* @__PURE__ */ import_react4.default.createElement("h1", { className: "text-2xl font-semibold" }, "Dashboard"), /* @__PURE__ */ import_react4.default.createElement("p", { className: "mt-2 text-white/70" }, "This page is hidden in Public Safe mode. Please sign in to continue."), /* @__PURE__ */ import_react4.default.createElement("div", { className: "mt-4" }, /* @__PURE__ */ import_react4.default.createElement( "a", { href: "/account/signin?callbackUrl=/dashboard", className: "inline-flex items-center justify-center px-4 py-2 rounded-xl bg-white text-black text-sm font-medium hover:bg-[#F3F4F6]" }, "Sign in" ))); } return /* @__PURE__ */ import_react4.default.createElement("div", { className: "mx-auto max-w-[1100px] px-6 py-6" }, isAdminOk ? /* @__PURE__ */ import_react4.default.createElement("div", { className: "flex justify-end mb-2" }, /* @__PURE__ */ import_react4.default.createElement("span", { className: "px-2 py-1 rounded-full text-[11px] border bg-white/10 text-white" }, "Safe: ", SAFE_MODE ? "ON" : "OFF", " (env:", envDefault ? "on" : "off", ", override:", String(settings?.safeModeOverride ?? "null"), ")")) : null, /* @__PURE__ */ import_react4.default.createElement(DashboardInner, { isAuthed })); } function DashboardInner({ isAuthed }) { const { urlParams, search, qField, createdFrom, createdTo, statusFilter, minBudget, maxBudget, page, pageSize, sortBy, sortOrder, updateParams, presets, setPresets, selectedPreset, setSelectedPreset, compact, setCompact, autoRefresh, setAutoRefresh, // NEW: extra toggles superCompact, setSuperCompact, wrapDesc, setWrapDesc, // NEW: selection selectedIds, selectAllActive, excludedIds, toggleRow, selectPage, clearSelection, setSelectAllActive } = useDashboardState(); const { rows, total, totalPages, totalsByStatus, isLoading, isError, error, isFetching } = useDashboardData({ search, qField, createdFrom, createdTo, minBudget, maxBudget, statusFilter, page, pageSize, sortBy, sortOrder, autoRefresh }); const { cloudPresets, saveViewMutation, deleteViewMutation } = useSavedViews(isAuthed); const effectivePresets = isAuthed ? cloudPresets : presets; const { handleExportCsv, handleReset, applyToday, apply7d, apply30d, saveCurrentView, applyPreset, deletePreset } = useDashboardActions({ urlParams, updateParams, isAuthed, presets, setPresets, selectedPreset, setSelectedPreset, effectivePresets, saveViewMutation, deleteViewMutation }); const { selectedTotal, visibleSelected } = (0, import_react4.useMemo)(() => { const pageIds = new Set(rows.map((r) => r.id)); let pageSelected = 0; for (const r of rows) { const chosen = selectAllActive ? !excludedIds.has(r.id) : selectedIds.has(r.id); if (chosen) pageSelected++; } const totalSelected = selectAllActive ? Math.max(0, (total || 0) - excludedIds.size) : selectedIds.size; return { selectedTotal: totalSelected, visibleSelected: pageSelected }; }, [rows, total, selectAllActive, excludedIds, selectedIds]); return /* @__PURE__ */ import_react4.default.createElement("div", { className: "w-full" }, /* @__PURE__ */ import_react4.default.createElement( DashboardHeader, { search, qField, updateParams, compact, setCompact, superCompact, setSuperCompact, wrapDesc, setWrapDesc, autoRefresh, setAutoRefresh, saveCurrentView, selectedPreset, setSelectedPreset, effectivePresets, isAuthed, applyPreset, deletePreset, handleExportCsv, handleReset, isFetching, isLoading } ), /* @__PURE__ */ import_react4.default.createElement( StatusChips, { totalsByStatus, statusFilter, updateParams } ), /* @__PURE__ */ import_react4.default.createElement( FilterControls, { statusFilter, minBudget, maxBudget, createdFrom, createdTo, updateParams } ), /* @__PURE__ */ import_react4.default.createElement( DateRangeChips, { createdFrom, createdTo, applyToday, apply7d, apply30d, updateParams } ), /* @__PURE__ */ import_react4.default.createElement("div", { className: "h-[1px] w-full bg-white/10 my-4" }), /* @__PURE__ */ import_react4.default.createElement("div", { className: "w-full overflow-x-auto" }, isLoading ? /* @__PURE__ */ import_react4.default.createElement("div", { className: `${compact ? "text-xs" : "text-sm"} text-white/80` }, /* @__PURE__ */ import_react4.default.createElement(SkeletonTable, null)) : isError ? /* @__PURE__ */ import_react4.default.createElement("div", { className: "text-sm text-red-400" }, error?.message || "Could not load data") : rows.length === 0 ? /* @__PURE__ */ import_react4.default.createElement("div", { className: "text-sm text-white/80" }, "No results") : /* @__PURE__ */ import_react4.default.createElement(import_react4.default.Fragment, null, /* @__PURE__ */ import_react4.default.createElement( JobsTable, { rows, total, totalPages, page, pageSize, sortBy, sortOrder, updateParams, compact, superCompact, wrapDesc, selectedIds, selectAllActive, excludedIds, toggleRow, selectPage, clearSelection, setSelectAllActive, selectedTotal, visibleSelected } ), /* @__PURE__ */ import_react4.default.createElement( PaginationControls, { page, totalPages, total, pageSize, updateParams, compact, superCompact, selectedTotal, visibleSelected } )))); } // virtual:/apps/web/src/app/layout.jsx init_injected_globals(); var import_react6 = __toESM(require_react()); // virtual:/apps/web/src/components/ErrorBoundary.jsx init_injected_globals(); var import_react5 = __toESM(require_react()); var ErrorBoundary = class extends import_react5.default.Component { constructor(props) { super(props); this.state = { hasError: false, error: null }; } static getDerivedStateFromError(error) { return { hasError: true, error }; } componentDidCatch(error, info) { try { console.error("App error boundary:", error, info); } catch (_) { } } render() { if (this.state.hasError) { return /* @__PURE__ */ import_react5.default.createElement("div", { className: "min-h-screen w-full flex items-center justify-center p-6 bg-[#F9FAFB]" }, /* @__PURE__ */ import_react5.default.createElement("div", { className: "max-w-lg w-full bg-white border rounded-xl p-6 text-center" }, /* @__PURE__ */ import_react5.default.createElement("h1", { className: "text-lg font-semibold text-[#111827] mb-2" }, "Something went wrong"), /* @__PURE__ */ import_react5.default.createElement("p", { className: "text-sm text-[#6B7280] mb-4" }, "Please refresh the page. If this keeps happening, try signing out and back in."), /* @__PURE__ */ import_react5.default.createElement("div", { className: "flex items-center justify-center gap-3" }, /* @__PURE__ */ import_react5.default.createElement( "button", { onClick: () => window.location.reload(), className: "px-3 py-2 text-sm rounded-md border hover:bg-[#F3F4F6]" }, "Reload" ), /* @__PURE__ */ import_react5.default.createElement( "a", { href: "/about", className: "px-3 py-2 text-sm rounded-md border hover:bg-[#F3F4F6]" }, "System status" )))); } return this.props.children; } }; // virtual:/apps/web/src/app/layout.jsx var import_meta2 = {}; var queryClient = new QueryClient({ defaultOptions: { queries: { staleTime: 1e3 * 60 * 5, cacheTime: 1e3 * 60 * 30, retry: 1, refetchOnWindowFocus: false } } }); function getPublicEnv2(key) { try { if (typeof import_meta2 !== "undefined" && import_meta2.env && key in import_meta2.env) { return import_meta2.env[key]; } } catch (_) { } try { if (typeof process !== "undefined" && process.env && key in process.env) { return process.env[key]; } } catch (_) { } try { if (typeof window !== "undefined" && window.__ENV__ && key in window.__ENV__) { return window.__ENV__[key]; } } catch (_) { } return void 0; } function getMode2() { try { if (typeof import_meta2 !== "undefined" && import_meta2.env && import_meta2.env.MODE) { return import_meta2.env.MODE; } } catch (_) { } try { if (typeof process !== "undefined" && process.env && "production") { return "production"; } } catch (_) { } return "production"; } function resolveSafeMode2() { const raw = getPublicEnv2("NEXT_PUBLIC_SAFE_MODE"); const val = String(raw || "").toLowerCase(); if (val === "off" || val === "false" || val === "0") return false; if (val === "on" || val === "true" || val === "1") return true; return getMode2() === "production"; } function DevIntercomBlocker() { (0, import_react6.useEffect)(() => { if (typeof window === "undefined") return; const isProd = getMode2() === "production"; if (!isProd) { try { if (typeof window.Intercom === "function") { try { window.Intercom("shutdown"); } catch (_) { } if (window.hasOwnProperty("Intercom")) delete window.Intercom; } if ("intercomSettings" in window) { try { delete window.intercomSettings; } catch (_) { } } } catch (e) { console.error(e); } } }, []); return null; } var FaviconLink = () => { const svg = encodeURIComponent( '' ); const href = `data:image/svg+xml,${svg}`; return /* @__PURE__ */ import_react6.default.createElement("link", { rel: "icon", href }); }; function StatusRibbon() { const { data: settings } = useQuery({ queryKey: ["safe-mode-override"], queryFn: async () => { const res = await fetch("/api/admin/settings", { cache: "no-store" }); if (!res.ok) return { safeModeOverride: null }; return res.json().catch(() => ({ safeModeOverride: null })); }, retry: 0, refetchOnWindowFocus: false, staleTime: 5 * 60 * 1e3 }); const envDefault = resolveSafeMode2(); const SAFE_MODE = settings?.safeModeOverride === "on" ? true : settings?.safeModeOverride === "off" ? false : envDefault; const { data, isFetching } = useQuery({ queryKey: ["health-ribbon"], queryFn: async () => { const res = await fetch("/api/health", { cache: "no-store" }); if (!res.ok) return { ok: false }; return res.json().catch(() => ({ ok: false })); }, refetchOnWindowFocus: false, retry: 0 }); const ok = Boolean(data?.ok); const label = ok ? "Status: OK" : isFetching ? "Checking status\u2026" : "Status: Issues detected"; const ribbonBg = ok ? "bg-[#063]" : "bg-[#7A3E00]"; const text2 = "text-white"; return /* @__PURE__ */ import_react6.default.createElement("div", { className: "w-full" }, SAFE_MODE ? /* @__PURE__ */ import_react6.default.createElement("div", { className: "w-full bg-[#0F172A] text-[11px] text-white/90" }, /* @__PURE__ */ import_react6.default.createElement("div", { className: "mx-auto max-w-[1100px] px-6 py-1.5 flex items-center justify-between" }, /* @__PURE__ */ import_react6.default.createElement("span", { className: "opacity-90" }, "Public Safe mode"), /* @__PURE__ */ import_react6.default.createElement( "a", { href: ok ? "/about" : "/admin/health", className: `px-2 py-0.5 rounded ${ribbonBg} ${text2}`, title: "View system health" }, label ))) : /* @__PURE__ */ import_react6.default.createElement("div", { className: "w-full bg-[#0F172A] text-[11px] text-white/90" }, /* @__PURE__ */ import_react6.default.createElement("div", { className: "mx-auto max-w-[1100px] px-6 py-1.5 flex items-center justify-end" }, /* @__PURE__ */ import_react6.default.createElement( "a", { href: ok ? "/about" : "/admin/health", className: `px-2 py-0.5 rounded ${ribbonBg} ${text2}`, title: "View system health" }, label )))); } function HeaderBar() { return /* @__PURE__ */ import_react6.default.createElement("div", { className: "w-full bg-[#0B1020] text-white" }, /* @__PURE__ */ import_react6.default.createElement("div", { className: "mx-auto max-w-[1100px] px-6 py-3 flex items-center justify-between" }, /* @__PURE__ */ import_react6.default.createElement("a", { href: "/", className: "text-sm font-semibold" }, "TutorTap"), /* @__PURE__ */ import_react6.default.createElement("nav", { className: "flex items-center gap-4" }, /* @__PURE__ */ import_react6.default.createElement("a", { href: "/about", className: "text-sm text-white/90 hover:text-white" }, "About"), /* @__PURE__ */ import_react6.default.createElement( "a", { href: "/help/user-manual", className: "text-sm text-white/90 hover:text-white" }, "Help" ), /* @__PURE__ */ import_react6.default.createElement("a", { href: "/quote", className: "text-sm text-white/90 hover:text-white" }, "AI quote"), /* @__PURE__ */ import_react6.default.createElement( "a", { href: "/account/signin", className: "text-sm text-white/90 hover:text-white" }, "Sign in" ))), /* @__PURE__ */ import_react6.default.createElement("div", { className: "h-[1px] w-full bg-white/10" })); } function ReferralsBootstrap() { const { data: user } = useUser_default(); const track = useMutation({ mutationFn: async ({ code, url }) => { const res = await fetch("/api/referrals/track", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ code, url }) }); if (!res.ok) { throw new Error( `When tracking referral, the response was [${res.status}] ${res.statusText}` ); } return res.json(); } }); (0, import_react6.useEffect)(() => { if (typeof window === "undefined") return; try { const params = new URLSearchParams(window.location.search); const code = params.get("ref"); if (code) { track.mutate({ code, url: window.location.href }); } } catch (e) { console.error(e); } }, []); useQuery({ queryKey: ["referrals-attribute"], enabled: !!user?.email, queryFn: async () => { const res = await fetch("/api/referrals/attribute", { method: "POST" }); if (!res.ok && res.status !== 401) { throw new Error( `When attributing referral, the response was [${res.status}] ${res.statusText}` ); } return res.json().catch(() => ({})); }, staleTime: 0, cacheTime: 0 }); return null; } function AuthSessionFetchPatch() { (0, import_react6.useEffect)(() => { if (typeof window === "undefined") return; const originalFetch = window.fetch; const patchedFetch = async (input, init) => { try { const url = typeof input === "string" ? input : input?.url; const shouldRewrite = typeof url === "string" && url.includes("/api/auth/session"); if (shouldRewrite) { const newUrl = url.replace("/api/auth/session", "/api/auth/token"); return originalFetch(newUrl, init); } } catch (_) { } return originalFetch(input, init); }; window.fetch = patchedFetch; return () => { window.fetch = originalFetch; }; }, []); return null; } function RootLayout({ children }) { return /* @__PURE__ */ import_react6.default.createElement(QueryClientProvider, { client: queryClient }, /* @__PURE__ */ import_react6.default.createElement(DevIntercomBlocker, null), /* @__PURE__ */ import_react6.default.createElement(AuthSessionFetchPatch, null), /* @__PURE__ */ import_react6.default.createElement(FaviconLink, null), /* @__PURE__ */ import_react6.default.createElement(StatusRibbon, null), /* @__PURE__ */ import_react6.default.createElement(HeaderBar, null), /* @__PURE__ */ import_react6.default.createElement(ReferralsBootstrap, null), /* @__PURE__ */ import_react6.default.createElement(ErrorBoundary, null, children)); } // virtual:/__wrapped_entry__.jsx function WrappedPage(props) { let content = /* @__PURE__ */ import_react7.default.createElement(DashboardPage, { ...props }); content = /* @__PURE__ */ import_react7.default.createElement(RootLayout, null, content); return content; } return __toCommonJS(wrapped_entry_exports); })(); /*! Bundled license information: react/cjs/react-jsx-runtime.production.min.js: (** * @license React * react-jsx-runtime.production.min.js * * Copyright (c) Facebook, Inc. and its affiliates. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. *) @tanstack/table-core/build/lib/index.mjs: (** * table-core * * Copyright (c) TanStack * * This source code is licensed under the MIT license found in the * LICENSE.md file in the root directory of this source tree. * * @license MIT *) @tanstack/react-table/build/lib/index.mjs: (** * react-table * * Copyright (c) TanStack * * This source code is licensed under the MIT license found in the * LICENSE.md file in the root directory of this source tree. * * @license MIT *) */