fastapi-rtk 0.1.14 → 0.1.15

package/dist/.external/cjs/@jsonforms_react@3.5.1_@jsonforms_core@3.5.1_react@18.3.1/@jsonforms/react/lib/jsonforms-react.esm.cjs

@@ -0,0 +1,381 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+const maxBy = require("../../../../../../.bundled/jsonforms/cjs/_virtual/maxBy.cjs");
+const jsonformsCore_esm = require("../../../../@jsonforms_core@3.5.1/@jsonforms/core/lib/jsonforms-core.esm.cjs");
+const debounce = require("../../../../../../.bundled/jsonforms/cjs/_virtual/debounce.cjs");
+class RendererComponent extends React.Component {
+  constructor(props) {
+    super(props);
+  }
+}
+class UnknownRenderer extends React.Component {
+  render() {
+    return React.createElement(
+      "div",
+      { style: { color: "red" } },
+      "No applicable ",
+      this.props.type,
+      " found."
+    );
+  }
+}
+const initialCoreState = {
+  data: {},
+  schema: {},
+  uischema: void 0,
+  errors: [],
+  additionalErrors: [],
+  validator: void 0,
+  ajv: void 0
+};
+const JsonFormsContext = React.createContext({
+  core: initialCoreState,
+  renderers: []
+});
+const useEffectAfterFirstRender = (effect, dependencies) => {
+  const firstExecution = React.useRef(true);
+  React.useEffect(() => {
+    if (firstExecution.current) {
+      firstExecution.current = false;
+      return;
+    }
+    effect();
+  }, dependencies);
+};
+const JsonFormsStateProvider = ({ children, initState, onChange, middleware }) => {
+  var _a, _b, _c;
+  const { data, schema, uischema, ajv, validationMode, additionalErrors } = initState.core;
+  const middlewareRef = React.useRef(middleware ?? jsonformsCore_esm.defaultMiddleware);
+  middlewareRef.current = middleware ?? jsonformsCore_esm.defaultMiddleware;
+  const [core, setCore] = React.useState(() => middlewareRef.current(initState.core, jsonformsCore_esm.Actions.init(data, schema, uischema, {
+    ajv,
+    validationMode,
+    additionalErrors
+  }), jsonformsCore_esm.coreReducer));
+  React.useEffect(() => setCore((currentCore) => middlewareRef.current(currentCore, jsonformsCore_esm.Actions.updateCore(data, schema, uischema, {
+    ajv,
+    validationMode,
+    additionalErrors
+  }), jsonformsCore_esm.coreReducer)), [data, schema, uischema, ajv, validationMode, additionalErrors]);
+  const [config, configDispatch] = React.useReducer(jsonformsCore_esm.configReducer, void 0, () => jsonformsCore_esm.configReducer(void 0, jsonformsCore_esm.Actions.setConfig(initState.config)));
+  useEffectAfterFirstRender(() => {
+    configDispatch(jsonformsCore_esm.Actions.setConfig(initState.config));
+  }, [initState.config]);
+  const [i18n, i18nDispatch] = React.useReducer(jsonformsCore_esm.i18nReducer, void 0, () => {
+    var _a2, _b2, _c2;
+    return jsonformsCore_esm.i18nReducer(initState.i18n, jsonformsCore_esm.Actions.updateI18n((_a2 = initState.i18n) == null ? void 0 : _a2.locale, (_b2 = initState.i18n) == null ? void 0 : _b2.translate, (_c2 = initState.i18n) == null ? void 0 : _c2.translateError));
+  });
+  React.useEffect(() => {
+    var _a2, _b2, _c2;
+    i18nDispatch(jsonformsCore_esm.Actions.updateI18n((_a2 = initState.i18n) == null ? void 0 : _a2.locale, (_b2 = initState.i18n) == null ? void 0 : _b2.translate, (_c2 = initState.i18n) == null ? void 0 : _c2.translateError));
+  }, [
+    (_a = initState.i18n) == null ? void 0 : _a.locale,
+    (_b = initState.i18n) == null ? void 0 : _b.translate,
+    (_c = initState.i18n) == null ? void 0 : _c.translateError
+  ]);
+  const dispatch = React.useCallback((action) => {
+    setCore((currentCore) => middlewareRef.current(currentCore, action, jsonformsCore_esm.coreReducer));
+  }, []);
+  const contextValue = React.useMemo(() => ({
+    core,
+    renderers: initState.renderers,
+    cells: initState.cells,
+    config,
+    uischemas: initState.uischemas,
+    readonly: initState.readonly,
+    i18n,
+    dispatch
+  }), [
+    core,
+    initState.renderers,
+    initState.cells,
+    config,
+    initState.uischemas,
+    initState.readonly,
+    i18n
+  ]);
+  const onChangeRef = React.useRef(onChange);
+  React.useEffect(() => {
+    onChangeRef.current = onChange;
+  }, [onChange]);
+  const debouncedEmit = React.useCallback(debounce((...args) => {
+    var _a2;
+    return (_a2 = onChangeRef.current) == null ? void 0 : _a2.call(onChangeRef, ...args);
+  }, 10), []);
+  React.useEffect(() => {
+    debouncedEmit({ data: core.data, errors: core.errors });
+  }, [core.data, core.errors]);
+  return React.createElement(JsonFormsContext.Provider, { value: contextValue }, children);
+};
+const useJsonForms = () => React.useContext(JsonFormsContext);
+const ctxToArrayLayoutProps = (ctx, props) => jsonformsCore_esm.mapStateToArrayLayoutProps({ jsonforms: { ...ctx } }, props);
+const ctxToLayoutProps = (ctx, props) => jsonformsCore_esm.mapStateToLayoutProps({ jsonforms: { ...ctx } }, props);
+const ctxToControlProps = (ctx, props) => jsonformsCore_esm.mapStateToControlProps({ jsonforms: { ...ctx } }, props);
+const ctxToEnumControlProps = (ctx, props) => {
+  var _a;
+  const enumProps = jsonformsCore_esm.mapStateToEnumControlProps({ jsonforms: { ...ctx } }, props);
+  const options = React.useMemo(() => enumProps.options, [props.options, enumProps.schema, (_a = ctx.i18n) == null ? void 0 : _a.translate]);
+  return { ...enumProps, options };
+};
+const ctxToOneOfEnumControlProps = (ctx, props) => {
+  var _a;
+  const enumProps = jsonformsCore_esm.mapStateToOneOfEnumControlProps({ jsonforms: { ...ctx } }, props);
+  const options = React.useMemo(() => enumProps.options, [props.options, enumProps.schema, (_a = ctx.i18n) == null ? void 0 : _a.translate]);
+  return { ...enumProps, options };
+};
+const ctxToMultiEnumControlProps = (ctx, props) => {
+  var _a;
+  const enumProps = jsonformsCore_esm.mapStateToMultiEnumControlProps({ jsonforms: { ...ctx } }, props);
+  const options = React.useMemo(() => enumProps.options, [enumProps.schema, (_a = ctx.i18n) == null ? void 0 : _a.translate]);
+  return { ...enumProps, options };
+};
+const ctxToControlWithDetailProps = (ctx, props) => jsonformsCore_esm.mapStateToControlWithDetailProps({ jsonforms: { ...ctx } }, props);
+const ctxDispatchToControlProps = (dispatch) => React.useMemo(() => jsonformsCore_esm.mapDispatchToControlProps(dispatch), [dispatch]);
+const ctxToJsonFormsRendererProps = (ctx, ownProps) => jsonformsCore_esm.mapStateToJsonFormsRendererProps({ jsonforms: { ...ctx } }, ownProps);
+const ctxDispatchToArrayControlProps = (dispatch) => ({
+  ...ctxDispatchToControlProps(dispatch),
+  ...React.useMemo(() => jsonformsCore_esm.mapDispatchToArrayControlProps(dispatch), [dispatch])
+});
+const ctxToCellProps = (ctx, ownProps) => {
+  return jsonformsCore_esm.mapStateToCellProps({ jsonforms: { ...ctx } }, ownProps);
+};
+const ctxToEnumCellProps = (ctx, ownProps) => {
+  var _a;
+  const cellProps = jsonformsCore_esm.defaultMapStateToEnumCellProps({ jsonforms: { ...ctx } }, ownProps);
+  const options = React.useMemo(() => cellProps.options, [ownProps.options, cellProps.schema, (_a = ctx.i18n) == null ? void 0 : _a.translate]);
+  return { ...cellProps, options };
+};
+const ctxToOneOfEnumCellProps = (ctx, props) => {
+  var _a;
+  const enumCellProps = jsonformsCore_esm.mapStateToOneOfEnumCellProps({ jsonforms: { ...ctx } }, props);
+  const options = React.useMemo(() => enumCellProps.options, [props.options, enumCellProps.schema, (_a = ctx.i18n) == null ? void 0 : _a.translate]);
+  return { ...enumCellProps, options };
+};
+const ctxToDispatchCellProps = (ctx, ownProps) => {
+  return jsonformsCore_esm.mapStateToDispatchCellProps({ jsonforms: { ...ctx } }, ownProps);
+};
+const ctxDispatchToMultiEnumProps = (dispatch) => ({
+  ...ctxDispatchToControlProps(dispatch),
+  ...React.useMemo(() => jsonformsCore_esm.mapDispatchToMultiEnumProps(dispatch), [dispatch])
+});
+const ctxToLabelProps = (ctx, ownProps) => {
+  return jsonformsCore_esm.mapStateToLabelProps({ jsonforms: { ...ctx } }, ownProps);
+};
+const withJsonFormsContext = (Component) => function WithJsonFormsContext(props) {
+  const ctx = useJsonForms();
+  return React.createElement(Component, { ctx, props });
+};
+const withContextToJsonFormsRendererProps = (Component) => function WithContextToJsonFormsRendererProps({ ctx, props }) {
+  const contextProps = ctxToJsonFormsRendererProps(ctx, props);
+  return React.createElement(Component, { ...props, ...contextProps });
+};
+const withContextToControlProps = (Component) => function WithContextToControlProps({ ctx, props }) {
+  const controlProps = ctxToControlProps(ctx, props);
+  const dispatchProps = ctxDispatchToControlProps(ctx.dispatch);
+  return React.createElement(Component, { ...props, ...controlProps, ...dispatchProps });
+};
+const withContextToLayoutProps = (Component) => function WithContextToLayoutProps({ ctx, props }) {
+  const layoutProps = ctxToLayoutProps(ctx, props);
+  return React.createElement(Component, { ...props, ...layoutProps });
+};
+const withContextToDetailProps = (Component) => function WithContextToDetailProps({ ctx, props }) {
+  const detailProps = ctxToControlWithDetailProps(ctx, props);
+  return React.createElement(Component, { ...props, ...detailProps });
+};
+const withContextToArrayLayoutProps = (Component) => function WithContextToArrayLayoutProps({ ctx, props }) {
+  const arrayLayoutProps = ctxToArrayLayoutProps(ctx, props);
+  const dispatchProps = ctxDispatchToArrayControlProps(ctx.dispatch);
+  return React.createElement(Component, { ...props, ...arrayLayoutProps, ...dispatchProps });
+};
+const withContextToCellProps = (Component) => function WithContextToCellProps({ ctx, props }) {
+  const cellProps = ctxToCellProps(ctx, props);
+  const dispatchProps = ctxDispatchToControlProps(ctx.dispatch);
+  return React.createElement(Component, { ...props, ...dispatchProps, ...cellProps });
+};
+const withContextToDispatchCellProps = (Component) => function WithContextToDispatchCellProps({ ctx, props }) {
+  const cellProps = ctxToDispatchCellProps(ctx, props);
+  const dispatchProps = ctxDispatchToControlProps(ctx.dispatch);
+  return React.createElement(Component, { ...props, ...dispatchProps, ...cellProps });
+};
+const withContextToEnumCellProps = (Component) => function WithContextToEnumCellProps({ ctx, props }) {
+  const cellProps = ctxToEnumCellProps(ctx, props);
+  const dispatchProps = ctxDispatchToControlProps(ctx.dispatch);
+  return React.createElement(Component, { ...props, ...dispatchProps, ...cellProps });
+};
+const withContextToEnumProps = (Component) => function WithContextToEnumProps({ ctx, props }) {
+  const stateProps = ctxToEnumControlProps(ctx, props);
+  const dispatchProps = ctxDispatchToControlProps(ctx.dispatch);
+  return React.createElement(Component, { ...props, ...dispatchProps, ...stateProps });
+};
+const withContextToOneOfEnumCellProps = (Component) => function WithContextToOneOfEnumCellProps({ ctx, props }) {
+  const cellProps = ctxToOneOfEnumCellProps(ctx, props);
+  const dispatchProps = ctxDispatchToControlProps(ctx.dispatch);
+  return React.createElement(Component, { ...props, ...dispatchProps, ...cellProps });
+};
+const withContextToOneOfEnumProps = (Component) => function WithContextToOneOfEnumProps({ ctx, props }) {
+  const stateProps = ctxToOneOfEnumControlProps(ctx, props);
+  const dispatchProps = ctxDispatchToControlProps(ctx.dispatch);
+  return React.createElement(Component, { ...props, ...dispatchProps, ...stateProps });
+};
+const withContextToMultiEnumProps = (Component) => function WithContextToMultiEnumProps({ ctx, props }) {
+  const stateProps = ctxToMultiEnumControlProps(ctx, props);
+  const dispatchProps = ctxDispatchToMultiEnumProps(ctx.dispatch);
+  return React.createElement(Component, { ...props, ...dispatchProps, ...stateProps });
+};
+const withContextToLabelProps = (Component) => function WithContextToLabelProps({ ctx, props }) {
+  const stateProps = ctxToLabelProps(ctx, props);
+  return React.createElement(Component, { ...props, ...stateProps });
+};
+const withJsonFormsRendererProps = (Component, memoize = true) => withJsonFormsContext(withContextToJsonFormsRendererProps(memoize ? React.memo(Component) : Component));
+const withJsonFormsControlProps = (Component, memoize = true) => withJsonFormsContext(withContextToControlProps(memoize ? React.memo(Component) : Component));
+const withJsonFormsLayoutProps = (Component, memoize = true) => withJsonFormsContext(withContextToLayoutProps(memoize ? React.memo(Component) : Component));
+const withJsonFormsDetailProps = (Component, memoize = true) => withJsonFormsContext(withContextToDetailProps(memoize ? React.memo(Component) : Component));
+const withJsonFormsArrayLayoutProps = (Component, memoize = true) => withJsonFormsContext(withContextToArrayLayoutProps(memoize ? React.memo(Component) : Component));
+const withJsonFormsCellProps = (Component, memoize = true) => withJsonFormsContext(withContextToCellProps(memoize ? React.memo(Component) : Component));
+const withJsonFormsDispatchCellProps = (Component, memoize = true) => withJsonFormsContext(withContextToDispatchCellProps(memoize ? React.memo(Component) : Component));
+const withJsonFormsEnumCellProps = (Component, memoize = true) => withJsonFormsContext(withContextToEnumCellProps(memoize ? React.memo(Component) : Component));
+const withJsonFormsEnumProps = (Component, memoize = true) => withJsonFormsContext(withContextToEnumProps(memoize ? React.memo(Component) : Component));
+const withJsonFormsOneOfEnumCellProps = (Component, memoize = true) => withJsonFormsContext(withContextToOneOfEnumCellProps(memoize ? React.memo(Component) : Component));
+const withJsonFormsOneOfEnumProps = (Component, memoize = true) => withJsonFormsContext(withContextToOneOfEnumProps(memoize ? React.memo(Component) : Component));
+const withJsonFormsMultiEnumProps = (Component, memoize = true) => withJsonFormsContext(withContextToMultiEnumProps(memoize ? React.memo(Component) : Component));
+const withJsonFormsLabelProps = (Component, memoize = true) => withJsonFormsContext(withContextToLabelProps(memoize ? React.memo(Component) : Component));
+const withTranslateProps = (Component) => function WithTranslateProps(props) {
+  var _a, _b;
+  const ctx = useJsonForms();
+  const locale = ((_a = ctx.i18n) == null ? void 0 : _a.locale) ?? jsonformsCore_esm.defaultJsonFormsI18nState.locale;
+  const t = ((_b = ctx.i18n) == null ? void 0 : _b.translate) ?? jsonformsCore_esm.defaultJsonFormsI18nState.translate;
+  return React.createElement(Component, { ...props, locale, t });
+};
+const withArrayTranslationProps = (Component) => function withArrayTranslatationProps(props) {
+  const translations = React.useMemo(() => jsonformsCore_esm.getArrayTranslations(props.t, jsonformsCore_esm.arrayDefaultTranslations, props.i18nKeyPrefix, props.label), [props.t, props.i18nKeyPrefix, props.label]);
+  return React.createElement(Component, { ...props, translations });
+};
+class JsonFormsDispatchRenderer extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      id: jsonformsCore_esm.isControl(props.uischema) ? jsonformsCore_esm.createId(props.uischema.scope) : void 0
+    };
+  }
+  componentWillUnmount() {
+    if (jsonformsCore_esm.isControl(this.props.uischema)) {
+      jsonformsCore_esm.removeId(this.state.id);
+    }
+  }
+  componentDidUpdate(prevProps) {
+    if (prevProps.schema !== this.props.schema) {
+      jsonformsCore_esm.removeId(this.state.id);
+      this.setState({
+        id: jsonformsCore_esm.isControl(this.props.uischema) ? jsonformsCore_esm.createId(this.props.uischema.scope) : void 0
+      });
+    }
+  }
+  render() {
+    const { schema, rootSchema, uischema, path, enabled, renderers, cells, config } = this.props;
+    return React.createElement(TestAndRender, { uischema, schema, rootSchema, path, enabled, renderers, cells, id: this.state.id, config });
+  }
+}
+const TestAndRender = React.memo(function TestAndRender2(props) {
+  const testerContext = React.useMemo(() => ({
+    rootSchema: props.rootSchema,
+    config: props.config
+  }), [props.rootSchema, props.config]);
+  const renderer = React.useMemo(() => maxBy(props.renderers, (r) => r.tester(props.uischema, props.schema, testerContext)), [props.renderers, props.uischema, props.schema, testerContext]);
+  if (renderer === void 0 || renderer.tester(props.uischema, props.schema, testerContext) === -1) {
+    return React.createElement(UnknownRenderer, { type: "renderer" });
+  } else {
+    const Render = renderer.renderer;
+    return React.createElement(Render, { uischema: props.uischema, schema: props.schema, path: props.path, enabled: props.enabled, renderers: props.renderers, cells: props.cells, id: props.id });
+  }
+});
+class ResolvedJsonFormsDispatchRenderer extends JsonFormsDispatchRenderer {
+  constructor(props) {
+    super(props);
+  }
+}
+const JsonFormsDispatch = withJsonFormsRendererProps(JsonFormsDispatchRenderer);
+withJsonFormsRendererProps(ResolvedJsonFormsDispatchRenderer);
+const JsonForms = (props) => {
+  const { ajv, data, schema, uischema, renderers, cells, onChange, config, uischemas, readonly, validationMode, i18n, additionalErrors, middleware } = props;
+  const schemaToUse = React.useMemo(() => schema !== void 0 ? schema : jsonformsCore_esm.Generate.jsonSchema(data), [schema, data]);
+  const uischemaToUse = React.useMemo(() => typeof uischema === "object" ? uischema : jsonformsCore_esm.Generate.uiSchema(schemaToUse, void 0, void 0, schemaToUse), [uischema, schemaToUse]);
+  return React.createElement(
+    JsonFormsStateProvider,
+    { initState: {
+      core: {
+        ajv,
+        data,
+        schema: schemaToUse,
+        uischema: uischemaToUse,
+        validationMode,
+        additionalErrors
+      },
+      config,
+      uischemas,
+      renderers,
+      cells,
+      readonly,
+      i18n
+    }, onChange, middleware },
+    React.createElement(JsonFormsDispatch, null)
+  );
+};
+const Dispatch = ({ uischema, schema, rootSchema, path, cells, id, enabled, renderers, config }) => {
+  const testerContext = React.useMemo(() => ({
+    rootSchema,
+    config
+  }), [rootSchema, config]);
+  const cell = React.useMemo(() => maxBy(cells, (r) => r.tester(uischema, schema, testerContext)), [cells, uischema, schema, testerContext]);
+  if (cell === void 0 || cell.tester(uischema, schema, testerContext) === -1) {
+    return React.createElement(UnknownRenderer, { type: "cell" });
+  } else {
+    const Cell = cell.cell;
+    return React.createElement(Cell, { uischema, schema, enabled, path, id, renderers, cells });
+  }
+};
+const DispatchCell = withJsonFormsDispatchCellProps(Dispatch);
+exports.Dispatch = Dispatch;
+exports.DispatchCell = DispatchCell;
+exports.JsonForms = JsonForms;
+exports.JsonFormsContext = JsonFormsContext;
+exports.JsonFormsDispatch = JsonFormsDispatch;
+exports.JsonFormsDispatchRenderer = JsonFormsDispatchRenderer;
+exports.JsonFormsStateProvider = JsonFormsStateProvider;
+exports.RendererComponent = RendererComponent;
+exports.ResolvedJsonFormsDispatchRenderer = ResolvedJsonFormsDispatchRenderer;
+exports.UnknownRenderer = UnknownRenderer;
+exports.ctxDispatchToArrayControlProps = ctxDispatchToArrayControlProps;
+exports.ctxDispatchToControlProps = ctxDispatchToControlProps;
+exports.ctxDispatchToMultiEnumProps = ctxDispatchToMultiEnumProps;
+exports.ctxToArrayLayoutProps = ctxToArrayLayoutProps;
+exports.ctxToCellProps = ctxToCellProps;
+exports.ctxToControlProps = ctxToControlProps;
+exports.ctxToControlWithDetailProps = ctxToControlWithDetailProps;
+exports.ctxToDispatchCellProps = ctxToDispatchCellProps;
+exports.ctxToEnumCellProps = ctxToEnumCellProps;
+exports.ctxToEnumControlProps = ctxToEnumControlProps;
+exports.ctxToJsonFormsRendererProps = ctxToJsonFormsRendererProps;
+exports.ctxToLabelProps = ctxToLabelProps;
+exports.ctxToLayoutProps = ctxToLayoutProps;
+exports.ctxToMultiEnumControlProps = ctxToMultiEnumControlProps;
+exports.ctxToOneOfEnumCellProps = ctxToOneOfEnumCellProps;
+exports.ctxToOneOfEnumControlProps = ctxToOneOfEnumControlProps;
+exports.useJsonForms = useJsonForms;
+exports.withArrayTranslationProps = withArrayTranslationProps;
+exports.withContextToJsonFormsRendererProps = withContextToJsonFormsRendererProps;
+exports.withJsonFormsArrayLayoutProps = withJsonFormsArrayLayoutProps;
+exports.withJsonFormsCellProps = withJsonFormsCellProps;
+exports.withJsonFormsContext = withJsonFormsContext;
+exports.withJsonFormsControlProps = withJsonFormsControlProps;
+exports.withJsonFormsDetailProps = withJsonFormsDetailProps;
+exports.withJsonFormsDispatchCellProps = withJsonFormsDispatchCellProps;
+exports.withJsonFormsEnumCellProps = withJsonFormsEnumCellProps;
+exports.withJsonFormsEnumProps = withJsonFormsEnumProps;
+exports.withJsonFormsLabelProps = withJsonFormsLabelProps;
+exports.withJsonFormsLayoutProps = withJsonFormsLayoutProps;
+exports.withJsonFormsMultiEnumProps = withJsonFormsMultiEnumProps;
+exports.withJsonFormsOneOfEnumCellProps = withJsonFormsOneOfEnumCellProps;
+exports.withJsonFormsOneOfEnumProps = withJsonFormsOneOfEnumProps;
+exports.withJsonFormsRendererProps = withJsonFormsRendererProps;
+exports.withTranslateProps = withTranslateProps;

package/dist/.external/cjs/@tanstack_react-query@5.75.2_react@18.3.1/@tanstack/react-query/build/modern/useBaseQuery.cjs

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+const notifyManager = require("../../../../../@tanstack_query-core@5.75.0/@tanstack/query-core/build/modern/notifyManager.cjs");
+const utils$1 = require("../../../../../@tanstack_query-core@5.75.0/@tanstack/query-core/build/modern/utils.cjs");
+const QueryClientProvider = require("./QueryClientProvider.cjs");
+const QueryErrorResetBoundary = require("./QueryErrorResetBoundary.cjs");
+const errorBoundaryUtils = require("./errorBoundaryUtils.cjs");
+const IsRestoringProvider = require("./IsRestoringProvider.cjs");
+const suspense = require("./suspense.cjs");
+const utils = require("./utils.cjs");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
+function useBaseQuery(options, Observer, queryClient) {
+  var _a, _b, _c, _d, _e;
+  if (process.env.NODE_ENV !== "production") {
+    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 = QueryClientProvider.useQueryClient();
+  const isRestoring = IsRestoringProvider.useIsRestoring();
+  const errorResetBoundary = QueryErrorResetBoundary.useQueryErrorResetBoundary();
+  const defaultedOptions = client.defaultQueryOptions(options);
+  (_b = (_a = client.getDefaultOptions().queries) == null ? void 0 : _a._experimental_beforeQuery) == null ? void 0 : _b.call(
+    _a,
+    defaultedOptions
+  );
+  if (process.env.NODE_ENV !== "production") {
+    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";
+  suspense.ensureSuspenseTimers(defaultedOptions);
+  errorBoundaryUtils.ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);
+  errorBoundaryUtils.useClearResetErrorBoundary(errorResetBoundary);
+  const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
+  const [observer] = React__namespace.useState(
+    () => new Observer(
+      client,
+      defaultedOptions
+    )
+  );
+  const result = observer.getOptimisticResult(defaultedOptions);
+  const shouldSubscribe = !isRestoring && options.subscribed !== false;
+  React__namespace.useSyncExternalStore(
+    React__namespace.useCallback(
+      (onStoreChange) => {
+        const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.notifyManager.batchCalls(onStoreChange)) : utils.noop;
+        observer.updateResult();
+        return unsubscribe;
+      },
+      [observer, shouldSubscribe]
+    ),
+    () => observer.getCurrentResult(),
+    () => observer.getCurrentResult()
+  );
+  React__namespace.useEffect(() => {
+    observer.setOptions(defaultedOptions);
+  }, [defaultedOptions, observer]);
+  if (suspense.shouldSuspend(defaultedOptions, result)) {
+    throw suspense.fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
+  }
+  if (errorBoundaryUtils.getHasError({
+    result,
+    errorResetBoundary,
+    throwOnError: defaultedOptions.throwOnError,
+    query: client.getQueryCache().get(defaultedOptions.queryHash),
+    suspense: defaultedOptions.suspense
+  })) {
+    throw result.error;
+  }
+  (_d = (_c = client.getDefaultOptions().queries) == null ? void 0 : _c._experimental_afterQuery) == null ? void 0 : _d.call(
+    _c,
+    defaultedOptions,
+    result
+  );
+  if (defaultedOptions.experimental_prefetchInRender && !utils$1.isServer && suspense.willFetch(result, isRestoring)) {
+    const promise = isNewCacheEntry ? (
+      // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
+      suspense.fetchOptimistic(defaultedOptions, observer, errorResetBoundary)
+    ) : (
+      // subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
+      (_e = client.getQueryCache().get(defaultedOptions.queryHash)) == null ? void 0 : _e.promise
+    );
+    promise == null ? void 0 : promise.catch(utils.noop).finally(() => {
+      observer.updateResult();
+    });
+  }
+  return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
+}
+exports.useBaseQuery = useBaseQuery;

package/dist/.external/cjs/@tanstack_react-query@5.75.2_react@18.3.1/@tanstack/react-query/build/modern/useQuery.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const queryObserver = require("../../../../../@tanstack_query-core@5.75.0/@tanstack/query-core/build/modern/queryObserver.cjs");
+const useBaseQuery = require("./useBaseQuery.cjs");
+function useQuery(options, queryClient) {
+  return useBaseQuery.useBaseQuery(options, queryObserver.QueryObserver);
+}
+exports.useQuery = useQuery;

package/dist/.external/cjs/@tanstack_react-table@8.20.5_react-dom@18.3.1_react@18.3.1/@tanstack/react-table/build/lib/index.cjs

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+const index = require("../../../../../@tanstack_table-core@8.20.5/@tanstack/table-core/build/lib/index.cjs");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
+/**
+   * 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
+   */
+function useReactTable(options) {
+  const resolvedOptions = {
+    state: {},
+    // Dummy state
+    onStateChange: () => {
+    },
+    // noop
+    renderFallbackValue: null,
+    ...options
+  };
+  const [tableRef] = React__namespace.useState(() => ({
+    current: index.createTable(resolvedOptions)
+  }));
+  const [state, setState] = React__namespace.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;
+}
+exports.ColumnFaceting = index.ColumnFaceting;
+exports.ColumnFiltering = index.ColumnFiltering;
+exports.ColumnGrouping = index.ColumnGrouping;
+exports.ColumnOrdering = index.ColumnOrdering;
+exports.ColumnPinning = index.ColumnPinning;
+exports.ColumnSizing = index.ColumnSizing;
+exports.ColumnVisibility = index.ColumnVisibility;
+exports.GlobalFaceting = index.GlobalFaceting;
+exports.GlobalFiltering = index.GlobalFiltering;
+exports.Headers = index.Headers;
+exports.RowExpanding = index.RowExpanding;
+exports.RowPagination = index.RowPagination;
+exports.RowPinning = index.RowPinning;
+exports.RowSelection = index.RowSelection;
+exports.RowSorting = index.RowSorting;
+exports._getVisibleLeafColumns = index._getVisibleLeafColumns;
+exports.aggregationFns = index.aggregationFns;
+exports.buildHeaderGroups = index.buildHeaderGroups;
+exports.createCell = index.createCell;
+exports.createColumn = index.createColumn;
+exports.createRow = index.createRow;
+exports.createTable = index.createTable;
+exports.defaultColumnSizing = index.defaultColumnSizing;
+exports.expandRows = index.expandRows;
+exports.filterFns = index.filterFns;
+exports.flattenBy = index.flattenBy;
+exports.functionalUpdate = index.functionalUpdate;
+exports.getCoreRowModel = index.getCoreRowModel;
+exports.getExpandedRowModel = index.getExpandedRowModel;
+exports.getFacetedMinMaxValues = index.getFacetedMinMaxValues;
+exports.getFacetedRowModel = index.getFacetedRowModel;
+exports.getFacetedUniqueValues = index.getFacetedUniqueValues;
+exports.getFilteredRowModel = index.getFilteredRowModel;
+exports.getGroupedRowModel = index.getGroupedRowModel;
+exports.getMemoOptions = index.getMemoOptions;
+exports.getPaginationRowModel = index.getPaginationRowModel;
+exports.getSortedRowModel = index.getSortedRowModel;
+exports.isFunction = index.isFunction;
+exports.isNumberArray = index.isNumberArray;
+exports.isRowSelected = index.isRowSelected;
+exports.isSubRowSelected = index.isSubRowSelected;
+exports.makeStateUpdater = index.makeStateUpdater;
+exports.memo = index.memo;
+exports.orderColumns = index.orderColumns;
+exports.passiveEventSupported = index.passiveEventSupported;
+exports.reSplitAlphaNumeric = index.reSplitAlphaNumeric;
+exports.selectRowsFn = index.selectRowsFn;
+exports.shouldAutoRemoveFilter = index.shouldAutoRemoveFilter;
+exports.sortingFns = index.sortingFns;
+exports.useReactTable = useReactTable;

package/dist/.external/cjs/@tanstack_react-virtual@3.11.2_react-dom@18.3.1_react@18.3.1/@tanstack/react-virtual/dist/esm/index.cjs

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+const reactDom = require("react-dom");
+const index = require("../../../../../@tanstack_virtual-core@3.11.2/@tanstack/virtual-core/dist/esm/index.cjs");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
+const useIsomorphicLayoutEffect = typeof document !== "undefined" ? React__namespace.useLayoutEffect : React__namespace.useEffect;
+function useVirtualizerBase(options) {
+  const rerender = React__namespace.useReducer(() => ({}), {})[1];
+  const resolvedOptions = {
+    ...options,
+    onChange: (instance2, sync) => {
+      var _a;
+      if (sync) {
+        reactDom.flushSync(rerender);
+      } else {
+        rerender();
+      }
+      (_a = options.onChange) == null ? void 0 : _a.call(options, instance2, sync);
+    }
+  };
+  const [instance] = React__namespace.useState(
+    () => new index.Virtualizer(resolvedOptions)
+  );
+  instance.setOptions(resolvedOptions);
+  useIsomorphicLayoutEffect(() => {
+    return instance._didMount();
+  }, []);
+  useIsomorphicLayoutEffect(() => {
+    return instance._willUpdate();
+  });
+  return instance;
+}
+function useVirtualizer(options) {
+  return useVirtualizerBase({
+    observeElementRect: index.observeElementRect,
+    observeElementOffset: index.observeElementOffset,
+    scrollToFn: index.elementScroll,
+    ...options
+  });
+}
+exports.Virtualizer = index.Virtualizer;
+exports.defaultKeyExtractor = index.defaultKeyExtractor;
+exports.defaultRangeExtractor = index.defaultRangeExtractor;
+exports.elementScroll = index.elementScroll;
+exports.measureElement = index.measureElement;
+exports.observeElementOffset = index.observeElementOffset;
+exports.observeElementRect = index.observeElementRect;
+exports.useVirtualizer = useVirtualizer;