@procore/saved-views 6.0.2 → 6.2.0

package/README.md

@@ -134,7 +134,15 @@ const MyDataTableView = () => {
   const savedViewsWrapperRef = useRef<IDataTableSavedViewsRef>(null);
 
   // Panel visibility control
-  const { SavedViewsButton, isOpen: isPanelOpen } = useSavedViewsPanel('your_domain', 'your_table');
+  // `SavedViewsProvider` is required if you want the `SavedViewsButton` label
+  // to display the currently active view name (e.g. "Views: My View"). Wrap
+  // the subtree that contains both the button and the `<DataTableSavedViews>`
+  // / `<SavedViews>` component below.
+  const {
+    SavedViewsButton,
+    SavedViewsProvider,
+    isOpen: isPanelOpen,
+  } = useSavedViewsPanel('your_domain', 'your_table');
 ```
 
 **Key Points**:
@@ -181,6 +189,7 @@ const defaultViewConfig = useMemo(
 
 ```tsx
   return (
+    <SavedViewsProvider>
     <div className="table-with-saved-views">
       <ServerSideDataTable
         columnDefinitions={columnDefinitions}
@@ -227,7 +236,7 @@ const defaultViewConfig = useMemo(
             {/* Top Controls */}
             <div style={{ display: 'flex', justifyContent: 'space-between', marginBottom: '12px' }}>
               <div style={{ display: 'flex', gap: '8px' }}>
-                <SavedViewsButton /> {/* Toggle saved views panel */}
+                <SavedViewsButton /> {/* Toggle saved views panel; shows active view name when wrapped in <SavedViewsProvider> */}
                 <ServerSideDataTable.Search />
                 <ServerSideDataTable.FiltersPanelButton />
               </div>
@@ -253,6 +262,7 @@ const defaultViewConfig = useMemo(
         </div>
       </ServerSideDataTable>
     </div>
+    </SavedViewsProvider>
   );
 };
 ```
@@ -263,6 +273,7 @@ const defaultViewConfig = useMemo(
 2. **API Sharing**: `tableApi={tableApi}` gives saved views control over table state
 3. **Config Sync**: `onTableConfigChange={handleTableConfigChange}` keeps everything in sync
 4. **Layout**: Saved views typically go in a left sidebar with fixed width
+5. **Active view label**: Wrapping the subtree in `<SavedViewsProvider>` lets the toggle button display the currently active view name (e.g. "Views: All RFIs"). The provider is a no-op when omitted, so existing integrations continue to render the plain "Views" label.
 
 ---
 

package/dist/legacy/adapters/hub-data-loader.d.mts

@@ -0,0 +1,22 @@
+import { SystemEvents } from '@procore/web-sdk-events';
+import { S as SavedViewsTransport } from '../types-BWhJ-on3.mjs';
+export { a as SavedViewsCacheControl, b as SavedViewsHttpRequest, c as SavedViewsMutationArgs, d as SavedViewsMutationResult, e as SavedViewsQueryArgs, f as SavedViewsQueryResult, g as SavedViewsUrlAdapter } from '../types-BWhJ-on3.mjs';
+import 'react';
+
+interface CreateHubDataLoaderTransportOptions {
+    /**
+     * Stable identifier of the Hub Card consuming saved-views. Forwarded to
+     * `useHubDataLoader(hubCardId, systemEvents)`. Use the same `HUB_CARD_ID`
+     * the card already uses elsewhere (e.g. for `system:request` events).
+     */
+    hubCardId: string;
+    /**
+     * The card's `SystemEvents` instance, initialized against the card's mount
+     * node. The Hub Card platform requires this to be scoped to the card, not
+     * `window`, so multiple cards on the same page don't cross-talk.
+     */
+    systemEvents: SystemEvents;
+}
+declare const createHubDataLoaderTransport: (options: CreateHubDataLoaderTransportOptions) => SavedViewsTransport;
+
+export { type CreateHubDataLoaderTransportOptions, SavedViewsTransport, createHubDataLoaderTransport };

package/dist/legacy/adapters/hub-data-loader.d.ts

@@ -0,0 +1,22 @@
+import { SystemEvents } from '@procore/web-sdk-events';
+import { S as SavedViewsTransport } from '../types-BWhJ-on3.js';
+export { a as SavedViewsCacheControl, b as SavedViewsHttpRequest, c as SavedViewsMutationArgs, d as SavedViewsMutationResult, e as SavedViewsQueryArgs, f as SavedViewsQueryResult, g as SavedViewsUrlAdapter } from '../types-BWhJ-on3.js';
+import 'react';
+
+interface CreateHubDataLoaderTransportOptions {
+    /**
+     * Stable identifier of the Hub Card consuming saved-views. Forwarded to
+     * `useHubDataLoader(hubCardId, systemEvents)`. Use the same `HUB_CARD_ID`
+     * the card already uses elsewhere (e.g. for `system:request` events).
+     */
+    hubCardId: string;
+    /**
+     * The card's `SystemEvents` instance, initialized against the card's mount
+     * node. The Hub Card platform requires this to be scoped to the card, not
+     * `window`, so multiple cards on the same page don't cross-talk.
+     */
+    systemEvents: SystemEvents;
+}
+declare const createHubDataLoaderTransport: (options: CreateHubDataLoaderTransportOptions) => SavedViewsTransport;
+
+export { type CreateHubDataLoaderTransportOptions, SavedViewsTransport, createHubDataLoaderTransport };

package/dist/legacy/adapters/hub-data-loader.js

@@ -0,0 +1,273 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }require('../chunk-QGM4M3NI.js');
+
+// src/transport/hub-data-loader.tsx
+
+
+
+
+
+
+
+
+
+var _react = require('react'); var _react2 = _interopRequireDefault(_react);
+
+
+var _websdkhubdataloader = require('@procore/web-sdk-hub-data-loader');
+var HubDataLoaderCache = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  getOrCreate(key) {
+    let entry = this.entries.get(key);
+    if (!entry) {
+      entry = { data: void 0, listeners: /* @__PURE__ */ new Set() };
+      this.entries.set(key, entry);
+    }
+    return entry;
+  }
+  subscribe(key, listener) {
+    const entry = this.getOrCreate(key);
+    entry.listeners.add(listener);
+    return () => {
+      entry.listeners.delete(listener);
+    };
+  }
+  get(key) {
+    var _a;
+    return (_a = this.entries.get(key)) == null ? void 0 : _a.data;
+  }
+  set(key, data) {
+    const entry = this.getOrCreate(key);
+    entry.data = data;
+    entry.listeners.forEach((listener) => listener());
+  }
+  invalidate(key) {
+    const entry = this.entries.get(key);
+    if (!entry) return;
+    entry.data = void 0;
+    entry.listeners.forEach((listener) => listener());
+  }
+};
+var stringifyQueryKey = (queryKey) => JSON.stringify(queryKey);
+var HubDataLoaderCacheContext = _react.createContext.call(void 0, void 0);
+var useHubDataLoaderCache = () => {
+  const ctx = _react.useContext.call(void 0, HubDataLoaderCacheContext);
+  if (!ctx) {
+    throw new Error(
+      "HubDataLoaderCacheProvider is missing. This indicates the saved-views transport was not constructed via createHubDataLoaderTransport()."
+    );
+  }
+  return ctx.cache;
+};
+var METHOD_TO_OPERATION_TYPE = {
+  GET: "GET",
+  POST: "POST",
+  PUT: "PUT",
+  DELETE: "DELETE"
+};
+var splitUrl = (url) => {
+  const queryIndex = url.indexOf("?");
+  if (queryIndex === -1) {
+    return { operationName: url, queryParams: {} };
+  }
+  const operationName = url.slice(0, queryIndex);
+  const search = new URLSearchParams(url.slice(queryIndex + 1));
+  const queryParams = {};
+  search.forEach((value, key) => {
+    queryParams[key] = value;
+  });
+  return { operationName, queryParams };
+};
+var parseBody = (body) => {
+  if (body === void 0 || body === null) return void 0;
+  if (typeof body === "string") {
+    try {
+      return JSON.parse(body);
+    } catch (e) {
+      return void 0;
+    }
+  }
+  if (typeof body === "object") {
+    return body;
+  }
+  return void 0;
+};
+var createHubDataLoaderTransport = (options) => {
+  const { hubCardId, systemEvents } = options;
+  const CacheProvider = ({ children }) => {
+    const cacheRef = _react.useRef.call(void 0, );
+    if (!cacheRef.current) {
+      cacheRef.current = new HubDataLoaderCache();
+    }
+    const value = _react.useMemo.call(void 0, 
+      () => ({ cache: cacheRef.current }),
+      []
+    );
+    return /* @__PURE__ */ _react2.default.createElement(HubDataLoaderCacheContext.Provider, { value }, children);
+  };
+  const useHttp = () => {
+    const { sendRequest } = _websdkhubdataloader.useHubDataLoader.call(void 0, hubCardId, systemEvents);
+    return _react.useCallback.call(void 0, 
+      async (req) => {
+        const { operationName, queryParams } = splitUrl(req.url);
+        const params = {
+          operationName,
+          operationType: METHOD_TO_OPERATION_TYPE[req.method],
+          queryParams,
+          body: parseBody(req.body),
+          headers: req.headers,
+          // Read saved-views GETs fresh from the network. This transport keeps
+          // its own local subscription cache (HubDataLoaderCache) and gates
+          // refetches on a local-cache miss, so it doesn't benefit from the
+          // host's stale-while-revalidate cache. Without preferFresh the host
+          // serves the GET via `ensureQueryData`, which returns the cached
+          // (pre-mutation) list — so a freshly created/renamed/deleted view
+          // wouldn't appear until the host cache expired. preferFresh routes
+          // the read through `fetchQuery({ staleTime: 0 })`, guaranteeing the
+          // post-mutation refetch reflects the change immediately.
+          preferFresh: req.method === "GET"
+        };
+        const response = await sendRequest(params);
+        if (response.error) {
+          throw response.error;
+        }
+        return response.responseData;
+      },
+      [sendRequest]
+    );
+  };
+  const useQueryAdapter = (args) => {
+    const cache = useHubDataLoaderCache();
+    const key = _react.useMemo.call(void 0, 
+      () => stringifyQueryKey(args.queryKey),
+      [args.queryKey]
+    );
+    const queryFnRef = _react.useRef.call(void 0, args.queryFn);
+    queryFnRef.current = args.queryFn;
+    const subscribe = _react.useCallback.call(void 0, 
+      (listener) => cache.subscribe(key, listener),
+      [cache, key]
+    );
+    const getSnapshot = _react.useCallback.call(void 0, 
+      () => cache.get(key),
+      [cache, key]
+    );
+    const data = _react.useSyncExternalStore.call(void 0, subscribe, getSnapshot, getSnapshot);
+    const [isLoading, setIsLoading] = _react.useState.call(void 0, 
+      args.enabled !== false && data === void 0
+    );
+    const [error, setError] = _react.useState.call(void 0, void 0);
+    const fetchInFlight = _react.useRef.call(void 0, false);
+    _react.useEffect.call(void 0, () => {
+      if (args.enabled === false) {
+        setIsLoading(false);
+        return;
+      }
+      if (data !== void 0) {
+        setIsLoading(false);
+        return;
+      }
+      if (fetchInFlight.current) return;
+      let abandoned = false;
+      fetchInFlight.current = true;
+      setIsLoading(true);
+      setError(void 0);
+      queryFnRef.current().then((result) => {
+        if (!abandoned) {
+          cache.set(key, result);
+          setError(void 0);
+        }
+      }).catch((err) => {
+        if (!abandoned) setError(err);
+      }).finally(() => {
+        if (!abandoned) {
+          fetchInFlight.current = false;
+          setIsLoading(false);
+        }
+      });
+      return () => {
+        abandoned = true;
+        fetchInFlight.current = false;
+      };
+    }, [cache, key, args.enabled, data]);
+    return {
+      data,
+      isLoading,
+      isError: error !== void 0,
+      error
+    };
+  };
+  const useMutationAdapter = (args) => {
+    const [isPending, setIsPending] = _react.useState.call(void 0, false);
+    const [error, setError] = _react.useState.call(void 0, null);
+    const mutationFnRef = _react.useRef.call(void 0, args.mutationFn);
+    const onSuccessRef = _react.useRef.call(void 0, args.onSuccess);
+    const onErrorRef = _react.useRef.call(void 0, args.onError);
+    mutationFnRef.current = args.mutationFn;
+    onSuccessRef.current = args.onSuccess;
+    onErrorRef.current = args.onError;
+    const mutate = _react.useCallback.call(void 0, 
+      (variables, callOptions) => {
+        setIsPending(true);
+        setError(null);
+        mutationFnRef.current(variables).then((result) => {
+          var _a, _b;
+          (_a = onSuccessRef.current) == null ? void 0 : _a.call(onSuccessRef, result, variables);
+          (_b = callOptions == null ? void 0 : callOptions.onSuccess) == null ? void 0 : _b.call(callOptions, result, variables);
+        }).catch((err) => {
+          var _a, _b;
+          setError(err);
+          (_a = onErrorRef.current) == null ? void 0 : _a.call(onErrorRef, err, variables);
+          (_b = callOptions == null ? void 0 : callOptions.onError) == null ? void 0 : _b.call(callOptions, err, variables);
+        }).finally(() => {
+          setIsPending(false);
+        });
+      },
+      []
+    );
+    const reset = _react.useCallback.call(void 0, () => {
+      setError(null);
+      setIsPending(false);
+    }, []);
+    return { mutate, isPending, error, reset };
+  };
+  const useCacheControl = () => {
+    const cache = useHubDataLoaderCache();
+    return {
+      invalidate: (queryKey) => {
+        cache.invalidate(stringifyQueryKey(queryKey));
+      },
+      setData: (queryKey, updater) => {
+        const key = stringifyQueryKey(queryKey);
+        const existing = cache.get(key);
+        const next = updater(existing);
+        cache.set(key, next);
+      },
+      getData: (queryKey) => cache.get(stringifyQueryKey(queryKey))
+    };
+  };
+  const useUrlAdapter = () => ({
+    // Hub Cards cannot read or write the host's URL. The host owns routing.
+    // The saved-views package falls back to localStorage-only persistence
+    // when these return null / no-op.
+    getViewToken: () => null,
+    setViewToken: () => {
+    }
+  });
+  return {
+    // Hub Cards cannot own the host URL, so the `?saved-view=<token>` share link
+    // cannot be read back on load. Hide the copy-link affordance in this context
+    // (see routing-in-hub-cards.md). The rest of saved views works unchanged.
+    supportsUrlSharing: false,
+    CacheProvider,
+    useHttp,
+    useQueryAdapter,
+    useMutationAdapter,
+    useCacheControl,
+    useUrlAdapter
+  };
+};
+
+
+exports.createHubDataLoaderTransport = createHubDataLoaderTransport;

package/dist/legacy/adapters/hub-data-loader.mjs

@@ -0,0 +1,273 @@
+import "../chunk-6DZX6EAA.mjs";
+
+// src/transport/hub-data-loader.tsx
+import React, {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  useSyncExternalStore
+} from "react";
+import {
+  useHubDataLoader
+} from "@procore/web-sdk-hub-data-loader";
+var HubDataLoaderCache = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  getOrCreate(key) {
+    let entry = this.entries.get(key);
+    if (!entry) {
+      entry = { data: void 0, listeners: /* @__PURE__ */ new Set() };
+      this.entries.set(key, entry);
+    }
+    return entry;
+  }
+  subscribe(key, listener) {
+    const entry = this.getOrCreate(key);
+    entry.listeners.add(listener);
+    return () => {
+      entry.listeners.delete(listener);
+    };
+  }
+  get(key) {
+    var _a;
+    return (_a = this.entries.get(key)) == null ? void 0 : _a.data;
+  }
+  set(key, data) {
+    const entry = this.getOrCreate(key);
+    entry.data = data;
+    entry.listeners.forEach((listener) => listener());
+  }
+  invalidate(key) {
+    const entry = this.entries.get(key);
+    if (!entry) return;
+    entry.data = void 0;
+    entry.listeners.forEach((listener) => listener());
+  }
+};
+var stringifyQueryKey = (queryKey) => JSON.stringify(queryKey);
+var HubDataLoaderCacheContext = createContext(void 0);
+var useHubDataLoaderCache = () => {
+  const ctx = useContext(HubDataLoaderCacheContext);
+  if (!ctx) {
+    throw new Error(
+      "HubDataLoaderCacheProvider is missing. This indicates the saved-views transport was not constructed via createHubDataLoaderTransport()."
+    );
+  }
+  return ctx.cache;
+};
+var METHOD_TO_OPERATION_TYPE = {
+  GET: "GET",
+  POST: "POST",
+  PUT: "PUT",
+  DELETE: "DELETE"
+};
+var splitUrl = (url) => {
+  const queryIndex = url.indexOf("?");
+  if (queryIndex === -1) {
+    return { operationName: url, queryParams: {} };
+  }
+  const operationName = url.slice(0, queryIndex);
+  const search = new URLSearchParams(url.slice(queryIndex + 1));
+  const queryParams = {};
+  search.forEach((value, key) => {
+    queryParams[key] = value;
+  });
+  return { operationName, queryParams };
+};
+var parseBody = (body) => {
+  if (body === void 0 || body === null) return void 0;
+  if (typeof body === "string") {
+    try {
+      return JSON.parse(body);
+    } catch {
+      return void 0;
+    }
+  }
+  if (typeof body === "object") {
+    return body;
+  }
+  return void 0;
+};
+var createHubDataLoaderTransport = (options) => {
+  const { hubCardId, systemEvents } = options;
+  const CacheProvider = ({ children }) => {
+    const cacheRef = useRef();
+    if (!cacheRef.current) {
+      cacheRef.current = new HubDataLoaderCache();
+    }
+    const value = useMemo(
+      () => ({ cache: cacheRef.current }),
+      []
+    );
+    return /* @__PURE__ */ React.createElement(HubDataLoaderCacheContext.Provider, { value }, children);
+  };
+  const useHttp = () => {
+    const { sendRequest } = useHubDataLoader(hubCardId, systemEvents);
+    return useCallback(
+      async (req) => {
+        const { operationName, queryParams } = splitUrl(req.url);
+        const params = {
+          operationName,
+          operationType: METHOD_TO_OPERATION_TYPE[req.method],
+          queryParams,
+          body: parseBody(req.body),
+          headers: req.headers,
+          // Read saved-views GETs fresh from the network. This transport keeps
+          // its own local subscription cache (HubDataLoaderCache) and gates
+          // refetches on a local-cache miss, so it doesn't benefit from the
+          // host's stale-while-revalidate cache. Without preferFresh the host
+          // serves the GET via `ensureQueryData`, which returns the cached
+          // (pre-mutation) list — so a freshly created/renamed/deleted view
+          // wouldn't appear until the host cache expired. preferFresh routes
+          // the read through `fetchQuery({ staleTime: 0 })`, guaranteeing the
+          // post-mutation refetch reflects the change immediately.
+          preferFresh: req.method === "GET"
+        };
+        const response = await sendRequest(params);
+        if (response.error) {
+          throw response.error;
+        }
+        return response.responseData;
+      },
+      [sendRequest]
+    );
+  };
+  const useQueryAdapter = (args) => {
+    const cache = useHubDataLoaderCache();
+    const key = useMemo(
+      () => stringifyQueryKey(args.queryKey),
+      [args.queryKey]
+    );
+    const queryFnRef = useRef(args.queryFn);
+    queryFnRef.current = args.queryFn;
+    const subscribe = useCallback(
+      (listener) => cache.subscribe(key, listener),
+      [cache, key]
+    );
+    const getSnapshot = useCallback(
+      () => cache.get(key),
+      [cache, key]
+    );
+    const data = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    const [isLoading, setIsLoading] = useState(
+      args.enabled !== false && data === void 0
+    );
+    const [error, setError] = useState(void 0);
+    const fetchInFlight = useRef(false);
+    useEffect(() => {
+      if (args.enabled === false) {
+        setIsLoading(false);
+        return;
+      }
+      if (data !== void 0) {
+        setIsLoading(false);
+        return;
+      }
+      if (fetchInFlight.current) return;
+      let abandoned = false;
+      fetchInFlight.current = true;
+      setIsLoading(true);
+      setError(void 0);
+      queryFnRef.current().then((result) => {
+        if (!abandoned) {
+          cache.set(key, result);
+          setError(void 0);
+        }
+      }).catch((err) => {
+        if (!abandoned) setError(err);
+      }).finally(() => {
+        if (!abandoned) {
+          fetchInFlight.current = false;
+          setIsLoading(false);
+        }
+      });
+      return () => {
+        abandoned = true;
+        fetchInFlight.current = false;
+      };
+    }, [cache, key, args.enabled, data]);
+    return {
+      data,
+      isLoading,
+      isError: error !== void 0,
+      error
+    };
+  };
+  const useMutationAdapter = (args) => {
+    const [isPending, setIsPending] = useState(false);
+    const [error, setError] = useState(null);
+    const mutationFnRef = useRef(args.mutationFn);
+    const onSuccessRef = useRef(args.onSuccess);
+    const onErrorRef = useRef(args.onError);
+    mutationFnRef.current = args.mutationFn;
+    onSuccessRef.current = args.onSuccess;
+    onErrorRef.current = args.onError;
+    const mutate = useCallback(
+      (variables, callOptions) => {
+        setIsPending(true);
+        setError(null);
+        mutationFnRef.current(variables).then((result) => {
+          var _a, _b;
+          (_a = onSuccessRef.current) == null ? void 0 : _a.call(onSuccessRef, result, variables);
+          (_b = callOptions == null ? void 0 : callOptions.onSuccess) == null ? void 0 : _b.call(callOptions, result, variables);
+        }).catch((err) => {
+          var _a, _b;
+          setError(err);
+          (_a = onErrorRef.current) == null ? void 0 : _a.call(onErrorRef, err, variables);
+          (_b = callOptions == null ? void 0 : callOptions.onError) == null ? void 0 : _b.call(callOptions, err, variables);
+        }).finally(() => {
+          setIsPending(false);
+        });
+      },
+      []
+    );
+    const reset = useCallback(() => {
+      setError(null);
+      setIsPending(false);
+    }, []);
+    return { mutate, isPending, error, reset };
+  };
+  const useCacheControl = () => {
+    const cache = useHubDataLoaderCache();
+    return {
+      invalidate: (queryKey) => {
+        cache.invalidate(stringifyQueryKey(queryKey));
+      },
+      setData: (queryKey, updater) => {
+        const key = stringifyQueryKey(queryKey);
+        const existing = cache.get(key);
+        const next = updater(existing);
+        cache.set(key, next);
+      },
+      getData: (queryKey) => cache.get(stringifyQueryKey(queryKey))
+    };
+  };
+  const useUrlAdapter = () => ({
+    // Hub Cards cannot read or write the host's URL. The host owns routing.
+    // The saved-views package falls back to localStorage-only persistence
+    // when these return null / no-op.
+    getViewToken: () => null,
+    setViewToken: () => {
+    }
+  });
+  return {
+    // Hub Cards cannot own the host URL, so the `?saved-view=<token>` share link
+    // cannot be read back on load. Hide the copy-link affordance in this context
+    // (see routing-in-hub-cards.md). The rest of saved views works unchanged.
+    supportsUrlSharing: false,
+    CacheProvider,
+    useHttp,
+    useQueryAdapter,
+    useMutationAdapter,
+    useCacheControl,
+    useUrlAdapter
+  };
+};
+export {
+  createHubDataLoaderTransport
+};

package/dist/legacy/chunk-6DZX6EAA.mjs

@@ -0,0 +1,37 @@
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};