fastapi-rtk 0.1.13 → 0.1.15

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/validation/limitNumber.mjs

@@ -0,0 +1,36 @@
+import { __exports as limitNumber } from "../../../../../../../.bundled/jsonforms/esm/_virtual/limitNumber.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+var hasRequiredLimitNumber;
+function requireLimitNumber() {
+  if (hasRequiredLimitNumber) return limitNumber;
+  hasRequiredLimitNumber = 1;
+  Object.defineProperty(limitNumber, "__esModule", { value: true });
+  const codegen_1 = requireCodegen();
+  const ops = codegen_1.operators;
+  const KWDs = {
+    maximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT },
+    minimum: { okStr: ">=", ok: ops.GTE, fail: ops.LT },
+    exclusiveMaximum: { okStr: "<", ok: ops.LT, fail: ops.GTE },
+    exclusiveMinimum: { okStr: ">", ok: ops.GT, fail: ops.LTE }
+  };
+  const error = {
+    message: ({ keyword, schemaCode }) => (0, codegen_1.str)`must be ${KWDs[keyword].okStr} ${schemaCode}`,
+    params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`
+  };
+  const def = {
+    keyword: Object.keys(KWDs),
+    type: "number",
+    schemaType: "number",
+    $data: true,
+    error,
+    code(cxt) {
+      const { keyword, data, schemaCode } = cxt;
+      cxt.fail$data((0, codegen_1._)`${data} ${KWDs[keyword].fail} ${schemaCode} || isNaN(${data})`);
+    }
+  };
+  limitNumber.default = def;
+  return limitNumber;
+}
+export {
+  requireLimitNumber as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/validation/limitProperties.mjs

@@ -0,0 +1,33 @@
+import { __exports as limitProperties } from "../../../../../../../.bundled/jsonforms/esm/_virtual/limitProperties.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+var hasRequiredLimitProperties;
+function requireLimitProperties() {
+  if (hasRequiredLimitProperties) return limitProperties;
+  hasRequiredLimitProperties = 1;
+  Object.defineProperty(limitProperties, "__esModule", { value: true });
+  const codegen_1 = requireCodegen();
+  const error = {
+    message({ keyword, schemaCode }) {
+      const comp = keyword === "maxProperties" ? "more" : "fewer";
+      return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} properties`;
+    },
+    params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
+  };
+  const def = {
+    keyword: ["maxProperties", "minProperties"],
+    type: "object",
+    schemaType: "number",
+    $data: true,
+    error,
+    code(cxt) {
+      const { keyword, data, schemaCode } = cxt;
+      const op = keyword === "maxProperties" ? codegen_1.operators.GT : codegen_1.operators.LT;
+      cxt.fail$data((0, codegen_1._)`Object.keys(${data}).length ${op} ${schemaCode}`);
+    }
+  };
+  limitProperties.default = def;
+  return limitProperties;
+}
+export {
+  requireLimitProperties as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/validation/multipleOf.mjs

@@ -0,0 +1,32 @@
+import { __exports as multipleOf } from "../../../../../../../.bundled/jsonforms/esm/_virtual/multipleOf.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+var hasRequiredMultipleOf;
+function requireMultipleOf() {
+  if (hasRequiredMultipleOf) return multipleOf;
+  hasRequiredMultipleOf = 1;
+  Object.defineProperty(multipleOf, "__esModule", { value: true });
+  const codegen_1 = requireCodegen();
+  const error = {
+    message: ({ schemaCode }) => (0, codegen_1.str)`must be multiple of ${schemaCode}`,
+    params: ({ schemaCode }) => (0, codegen_1._)`{multipleOf: ${schemaCode}}`
+  };
+  const def = {
+    keyword: "multipleOf",
+    type: "number",
+    schemaType: "number",
+    $data: true,
+    error,
+    code(cxt) {
+      const { gen, data, schemaCode, it } = cxt;
+      const prec = it.opts.multipleOfPrecision;
+      const res = gen.let("res");
+      const invalid = prec ? (0, codegen_1._)`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}` : (0, codegen_1._)`${res} !== parseInt(${res})`;
+      cxt.fail$data((0, codegen_1._)`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid}))`);
+    }
+  };
+  multipleOf.default = def;
+  return multipleOf;
+}
+export {
+  requireMultipleOf as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/validation/pattern.mjs

@@ -0,0 +1,33 @@
+import { __exports as pattern } from "../../../../../../../.bundled/jsonforms/esm/_virtual/pattern.mjs";
+import { __require as requireCode } from "../code.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+var hasRequiredPattern;
+function requirePattern() {
+  if (hasRequiredPattern) return pattern;
+  hasRequiredPattern = 1;
+  Object.defineProperty(pattern, "__esModule", { value: true });
+  const code_1 = requireCode();
+  const codegen_1 = requireCodegen();
+  const error = {
+    message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
+    params: ({ schemaCode }) => (0, codegen_1._)`{pattern: ${schemaCode}}`
+  };
+  const def = {
+    keyword: "pattern",
+    type: "string",
+    schemaType: "string",
+    $data: true,
+    error,
+    code(cxt) {
+      const { data, $data, schema, schemaCode, it } = cxt;
+      const u = it.opts.unicodeRegExp ? "u" : "";
+      const regExp = $data ? (0, codegen_1._)`(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema);
+      cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+    }
+  };
+  pattern.default = def;
+  return pattern;
+}
+export {
+  requirePattern as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/validation/required.mjs

@@ -0,0 +1,88 @@
+import { __exports as required } from "../../../../../../../.bundled/jsonforms/esm/_virtual/required.mjs";
+import { __require as requireCode } from "../code.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+import { __require as requireUtil } from "../../compile/util.mjs";
+var hasRequiredRequired;
+function requireRequired() {
+  if (hasRequiredRequired) return required;
+  hasRequiredRequired = 1;
+  Object.defineProperty(required, "__esModule", { value: true });
+  const code_1 = requireCode();
+  const codegen_1 = requireCodegen();
+  const util_1 = requireUtil();
+  const error = {
+    message: ({ params: { missingProperty } }) => (0, codegen_1.str)`must have required property '${missingProperty}'`,
+    params: ({ params: { missingProperty } }) => (0, codegen_1._)`{missingProperty: ${missingProperty}}`
+  };
+  const def = {
+    keyword: "required",
+    type: "object",
+    schemaType: "array",
+    $data: true,
+    error,
+    code(cxt) {
+      const { gen, schema, schemaCode, data, $data, it } = cxt;
+      const { opts } = it;
+      if (!$data && schema.length === 0)
+        return;
+      const useLoop = schema.length >= opts.loopRequired;
+      if (it.allErrors)
+        allErrorsMode();
+      else
+        exitOnErrorMode();
+      if (opts.strictRequired) {
+        const props = cxt.parentSchema.properties;
+        const { definedProperties } = cxt.it;
+        for (const requiredKey of schema) {
+          if ((props === null || props === void 0 ? void 0 : props[requiredKey]) === void 0 && !definedProperties.has(requiredKey)) {
+            const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
+            const msg = `required property "${requiredKey}" is not defined at "${schemaPath}" (strictRequired)`;
+            (0, util_1.checkStrictMode)(it, msg, it.opts.strictRequired);
+          }
+        }
+      }
+      function allErrorsMode() {
+        if (useLoop || $data) {
+          cxt.block$data(codegen_1.nil, loopAllRequired);
+        } else {
+          for (const prop of schema) {
+            (0, code_1.checkReportMissingProp)(cxt, prop);
+          }
+        }
+      }
+      function exitOnErrorMode() {
+        const missing = gen.let("missing");
+        if (useLoop || $data) {
+          const valid = gen.let("valid", true);
+          cxt.block$data(valid, () => loopUntilMissing(missing, valid));
+          cxt.ok(valid);
+        } else {
+          gen.if((0, code_1.checkMissingProp)(cxt, schema, missing));
+          (0, code_1.reportMissingProp)(cxt, missing);
+          gen.else();
+        }
+      }
+      function loopAllRequired() {
+        gen.forOf("prop", schemaCode, (prop) => {
+          cxt.setParams({ missingProperty: prop });
+          gen.if((0, code_1.noPropertyInData)(gen, data, prop, opts.ownProperties), () => cxt.error());
+        });
+      }
+      function loopUntilMissing(missing, valid) {
+        cxt.setParams({ missingProperty: missing });
+        gen.forOf(missing, schemaCode, () => {
+          gen.assign(valid, (0, code_1.propertyInData)(gen, data, missing, opts.ownProperties));
+          gen.if((0, codegen_1.not)(valid), () => {
+            cxt.error();
+            gen.break();
+          });
+        }, codegen_1.nil);
+      }
+    }
+  };
+  required.default = def;
+  return required;
+}
+export {
+  requireRequired as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/validation/uniqueItems.mjs

@@ -0,0 +1,74 @@
+import { __exports as uniqueItems } from "../../../../../../../.bundled/jsonforms/esm/_virtual/uniqueItems.mjs";
+import { __require as requireDataType } from "../../compile/validate/dataType.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+import { __require as requireUtil } from "../../compile/util.mjs";
+import { __require as requireEqual } from "../../runtime/equal.mjs";
+var hasRequiredUniqueItems;
+function requireUniqueItems() {
+  if (hasRequiredUniqueItems) return uniqueItems;
+  hasRequiredUniqueItems = 1;
+  Object.defineProperty(uniqueItems, "__esModule", { value: true });
+  const dataType_1 = requireDataType();
+  const codegen_1 = requireCodegen();
+  const util_1 = requireUtil();
+  const equal_1 = requireEqual();
+  const error = {
+    message: ({ params: { i, j } }) => (0, codegen_1.str)`must NOT have duplicate items (items ## ${j} and ${i} are identical)`,
+    params: ({ params: { i, j } }) => (0, codegen_1._)`{i: ${i}, j: ${j}}`
+  };
+  const def = {
+    keyword: "uniqueItems",
+    type: "array",
+    schemaType: "boolean",
+    $data: true,
+    error,
+    code(cxt) {
+      const { gen, data, $data, schema, parentSchema, schemaCode, it } = cxt;
+      if (!$data && !schema)
+        return;
+      const valid = gen.let("valid");
+      const itemTypes = parentSchema.items ? (0, dataType_1.getSchemaTypes)(parentSchema.items) : [];
+      cxt.block$data(valid, validateUniqueItems, (0, codegen_1._)`${schemaCode} === false`);
+      cxt.ok(valid);
+      function validateUniqueItems() {
+        const i = gen.let("i", (0, codegen_1._)`${data}.length`);
+        const j = gen.let("j");
+        cxt.setParams({ i, j });
+        gen.assign(valid, true);
+        gen.if((0, codegen_1._)`${i} > 1`, () => (canOptimize() ? loopN : loopN2)(i, j));
+      }
+      function canOptimize() {
+        return itemTypes.length > 0 && !itemTypes.some((t) => t === "object" || t === "array");
+      }
+      function loopN(i, j) {
+        const item = gen.name("item");
+        const wrongType = (0, dataType_1.checkDataTypes)(itemTypes, item, it.opts.strictNumbers, dataType_1.DataType.Wrong);
+        const indices = gen.const("indices", (0, codegen_1._)`{}`);
+        gen.for((0, codegen_1._)`;${i}--;`, () => {
+          gen.let(item, (0, codegen_1._)`${data}[${i}]`);
+          gen.if(wrongType, (0, codegen_1._)`continue`);
+          if (itemTypes.length > 1)
+            gen.if((0, codegen_1._)`typeof ${item} == "string"`, (0, codegen_1._)`${item} += "_"`);
+          gen.if((0, codegen_1._)`typeof ${indices}[${item}] == "number"`, () => {
+            gen.assign(j, (0, codegen_1._)`${indices}[${item}]`);
+            cxt.error();
+            gen.assign(valid, false).break();
+          }).code((0, codegen_1._)`${indices}[${item}] = ${i}`);
+        });
+      }
+      function loopN2(i, j) {
+        const eql = (0, util_1.useFunc)(gen, equal_1.default);
+        const outer = gen.name("outer");
+        gen.label(outer).for((0, codegen_1._)`;${i}--;`, () => gen.for((0, codegen_1._)`${j} = ${i}; ${j}--;`, () => gen.if((0, codegen_1._)`${eql}(${data}[${i}], ${data}[${j}])`, () => {
+          cxt.error();
+          gen.assign(valid, false).break(outer);
+        })));
+      }
+    }
+  };
+  uniqueItems.default = def;
+  return uniqueItems;
+}
+export {
+  requireUniqueItems as __require
+};

package/dist/.external/esm/clsx@2.1.1/clsx/dist/clsx.mjs

@@ -0,0 +1,17 @@
+function r(e) {
+  var t, f, n = "";
+  if ("string" == typeof e || "number" == typeof e) n += e;
+  else if ("object" == typeof e) if (Array.isArray(e)) {
+    var o = e.length;
+    for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+  } else for (f in e) e[f] && (n && (n += " "), n += f);
+  return n;
+}
+function clsx() {
+  for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
+export {
+  clsx,
+  clsx as default
+};