Santhosh Janardhanan
de2d83092e
- Delete old Vite+Svelte frontend - Initialize new SvelteKit project with TypeScript - Configure Tailwind CSS v4 + DaisyUI - Implement JWT authentication with auto-refresh - Create login page with form validation (Zod) - Add protected route guards - Update Docker configuration for single-stage build - Add E2E tests with Playwright (6/11 passing) - Fix Svelte 5 reactivity with $state() runes Known issues: - 5 E2E tests failing (timing/async issues) - Token refresh implementation needs debugging - Validation error display timing
545 lines
19 KiB
JavaScript
545 lines
19 KiB
JavaScript
//#region rolldown:runtime
|
|
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 __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
|
|
key = keys[i];
|
|
if (!__hasOwnProp.call(to, key) && key !== except) {
|
|
__defProp(to, key, {
|
|
get: ((k) => from[k]).bind(null, key),
|
|
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return to;
|
|
};
|
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
|
|
value: mod,
|
|
enumerable: true
|
|
}) : target, mod));
|
|
|
|
//#endregion
|
|
let valibot = require("valibot");
|
|
valibot = __toESM(valibot);
|
|
|
|
//#region src/utils/addError.ts
|
|
/**
|
|
* Adds an error message to the errors array.
|
|
*
|
|
* @param errors The array of error messages.
|
|
* @param message The error message to add.
|
|
*
|
|
* @returns The new errors.
|
|
*/
|
|
function addError(errors, message) {
|
|
if (errors) {
|
|
errors.push(message);
|
|
return errors;
|
|
}
|
|
return [message];
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/utils/handleError.ts
|
|
/**
|
|
* Throws an error or logs a warning based on the configuration.
|
|
*
|
|
* @param message The message to throw or log.
|
|
* @param config The conversion configuration.
|
|
*/
|
|
function handleError(message, config) {
|
|
switch (config?.errorMode) {
|
|
case "ignore": break;
|
|
case "warn":
|
|
console.warn(message);
|
|
break;
|
|
default: throw new Error(message);
|
|
}
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/converters/convertAction/convertAction.ts
|
|
/**
|
|
* Converts any supported Valibot action to the JSON Schema format.
|
|
*
|
|
* @param jsonSchema The JSON Schema object.
|
|
* @param valibotAction The Valibot action object.
|
|
* @param config The conversion configuration.
|
|
*
|
|
* @returns The converted JSON Schema.
|
|
*/
|
|
function convertAction(jsonSchema, valibotAction, config) {
|
|
if (config?.ignoreActions?.includes(valibotAction.type)) return jsonSchema;
|
|
let errors;
|
|
switch (valibotAction.type) {
|
|
case "base64":
|
|
jsonSchema.contentEncoding = "base64";
|
|
break;
|
|
case "bic":
|
|
case "cuid2":
|
|
case "decimal":
|
|
case "digits":
|
|
case "emoji":
|
|
case "hexadecimal":
|
|
case "hex_color":
|
|
case "nanoid":
|
|
case "octal":
|
|
case "ulid":
|
|
jsonSchema.pattern = valibotAction.requirement.source;
|
|
break;
|
|
case "description":
|
|
jsonSchema.description = valibotAction.description;
|
|
break;
|
|
case "email":
|
|
jsonSchema.format = "email";
|
|
break;
|
|
case "empty":
|
|
if (jsonSchema.type === "array") jsonSchema.maxItems = 0;
|
|
else {
|
|
if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
|
|
jsonSchema.maxLength = 0;
|
|
}
|
|
break;
|
|
case "entries":
|
|
jsonSchema.minProperties = valibotAction.requirement;
|
|
jsonSchema.maxProperties = valibotAction.requirement;
|
|
break;
|
|
case "examples":
|
|
if (Array.isArray(jsonSchema.examples)) jsonSchema.examples = [...jsonSchema.examples, ...valibotAction.examples];
|
|
else jsonSchema.examples = valibotAction.examples;
|
|
break;
|
|
case "integer":
|
|
jsonSchema.type = "integer";
|
|
break;
|
|
case "ipv4":
|
|
jsonSchema.format = "ipv4";
|
|
break;
|
|
case "ipv6":
|
|
jsonSchema.format = "ipv6";
|
|
break;
|
|
case "iso_date":
|
|
jsonSchema.format = "date";
|
|
break;
|
|
case "iso_date_time":
|
|
case "iso_timestamp":
|
|
jsonSchema.format = "date-time";
|
|
break;
|
|
case "iso_time":
|
|
jsonSchema.format = "time";
|
|
break;
|
|
case "length":
|
|
if (jsonSchema.type === "array") {
|
|
jsonSchema.minItems = valibotAction.requirement;
|
|
jsonSchema.maxItems = valibotAction.requirement;
|
|
} else {
|
|
if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
|
|
jsonSchema.minLength = valibotAction.requirement;
|
|
jsonSchema.maxLength = valibotAction.requirement;
|
|
}
|
|
break;
|
|
case "max_entries":
|
|
jsonSchema.maxProperties = valibotAction.requirement;
|
|
break;
|
|
case "max_length":
|
|
if (jsonSchema.type === "array") jsonSchema.maxItems = valibotAction.requirement;
|
|
else {
|
|
if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
|
|
jsonSchema.maxLength = valibotAction.requirement;
|
|
}
|
|
break;
|
|
case "max_value":
|
|
if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") errors = addError(errors, `The "max_value" action is not supported on type "${jsonSchema.type}".`);
|
|
jsonSchema.maximum = valibotAction.requirement;
|
|
break;
|
|
case "metadata":
|
|
if (typeof valibotAction.metadata.title === "string") jsonSchema.title = valibotAction.metadata.title;
|
|
if (typeof valibotAction.metadata.description === "string") jsonSchema.description = valibotAction.metadata.description;
|
|
if (Array.isArray(valibotAction.metadata.examples)) if (Array.isArray(jsonSchema.examples)) jsonSchema.examples = [...jsonSchema.examples, ...valibotAction.metadata.examples];
|
|
else jsonSchema.examples = valibotAction.metadata.examples;
|
|
break;
|
|
case "min_entries":
|
|
jsonSchema.minProperties = valibotAction.requirement;
|
|
break;
|
|
case "min_length":
|
|
if (jsonSchema.type === "array") jsonSchema.minItems = valibotAction.requirement;
|
|
else {
|
|
if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
|
|
jsonSchema.minLength = valibotAction.requirement;
|
|
}
|
|
break;
|
|
case "min_value":
|
|
if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") errors = addError(errors, `The "min_value" action is not supported on type "${jsonSchema.type}".`);
|
|
jsonSchema.minimum = valibotAction.requirement;
|
|
break;
|
|
case "multiple_of":
|
|
jsonSchema.multipleOf = valibotAction.requirement;
|
|
break;
|
|
case "non_empty":
|
|
if (jsonSchema.type === "array") jsonSchema.minItems = 1;
|
|
else {
|
|
if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
|
|
jsonSchema.minLength = 1;
|
|
}
|
|
break;
|
|
case "regex":
|
|
if (valibotAction.requirement.flags) errors = addError(errors, "RegExp flags are not supported by JSON Schema.");
|
|
jsonSchema.pattern = valibotAction.requirement.source;
|
|
break;
|
|
case "title":
|
|
jsonSchema.title = valibotAction.title;
|
|
break;
|
|
case "url":
|
|
jsonSchema.format = "uri";
|
|
break;
|
|
case "uuid":
|
|
jsonSchema.format = "uuid";
|
|
break;
|
|
case "value":
|
|
jsonSchema.const = valibotAction.requirement;
|
|
break;
|
|
default: errors = addError(errors, `The "${valibotAction.type}" action cannot be converted to JSON Schema.`);
|
|
}
|
|
if (config?.overrideAction) {
|
|
const actionOverride = config.overrideAction({
|
|
valibotAction,
|
|
jsonSchema,
|
|
errors
|
|
});
|
|
if (actionOverride) return { ...actionOverride };
|
|
}
|
|
if (errors) for (const message of errors) handleError(message, config);
|
|
return jsonSchema;
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/converters/convertSchema/convertSchema.ts
|
|
/**
|
|
* Flattens a Valibot pipe by recursively expanding nested pipes.
|
|
*
|
|
* @param pipe The pipeline to flatten.
|
|
*
|
|
* @returns A flat pipeline.
|
|
*/
|
|
function flattenPipe(pipe) {
|
|
return pipe.flatMap((item) => "pipe" in item ? flattenPipe(item.pipe) : item);
|
|
}
|
|
let refCount = 0;
|
|
/**
|
|
* Converts any supported Valibot schema to the JSON Schema format.
|
|
*
|
|
* @param jsonSchema The JSON Schema object.
|
|
* @param valibotSchema The Valibot schema object.
|
|
* @param config The conversion configuration.
|
|
* @param context The conversion context.
|
|
* @param skipRef Whether to skip using a reference.
|
|
*
|
|
* @returns The converted JSON Schema.
|
|
*/
|
|
function convertSchema(jsonSchema, valibotSchema, config, context, skipRef = false) {
|
|
if (!skipRef) {
|
|
const referenceId = context.referenceMap.get(valibotSchema);
|
|
if (referenceId) {
|
|
jsonSchema.$ref = `#/$defs/${referenceId}`;
|
|
if (config?.overrideRef) {
|
|
const refOverride = config.overrideRef({
|
|
...context,
|
|
referenceId,
|
|
valibotSchema,
|
|
jsonSchema
|
|
});
|
|
if (refOverride) jsonSchema.$ref = refOverride;
|
|
}
|
|
return jsonSchema;
|
|
}
|
|
}
|
|
if ("pipe" in valibotSchema) {
|
|
const flatPipe = flattenPipe(valibotSchema.pipe);
|
|
let startIndex = 0;
|
|
let stopIndex = flatPipe.length - 1;
|
|
if (config?.typeMode === "input") {
|
|
const inputStopIndex = flatPipe.slice(1).findIndex((item) => item.kind === "schema" || item.kind === "transformation" && (item.type === "find_item" || item.type === "parse_json" || item.type === "raw_transform" || item.type === "reduce_items" || item.type === "stringify_json" || item.type === "to_bigint" || item.type === "to_boolean" || item.type === "to_date" || item.type === "to_number" || item.type === "to_string" || item.type === "transform"));
|
|
if (inputStopIndex !== -1) stopIndex = inputStopIndex;
|
|
} else if (config?.typeMode === "output") {
|
|
const outputStartIndex = flatPipe.findLastIndex((item) => item.kind === "schema");
|
|
if (outputStartIndex !== -1) startIndex = outputStartIndex;
|
|
}
|
|
for (let index = startIndex; index <= stopIndex; index++) {
|
|
const valibotPipeItem = flatPipe[index];
|
|
if (valibotPipeItem.kind === "schema") {
|
|
if (index > startIndex) handleError("Set the \"typeMode\" config to \"input\" or \"output\" to convert pipelines with multiple schemas.", config);
|
|
jsonSchema = convertSchema(jsonSchema, valibotPipeItem, config, context, true);
|
|
} else jsonSchema = convertAction(jsonSchema, valibotPipeItem, config);
|
|
}
|
|
return jsonSchema;
|
|
}
|
|
let errors;
|
|
switch (valibotSchema.type) {
|
|
case "boolean":
|
|
jsonSchema.type = "boolean";
|
|
break;
|
|
case "null":
|
|
if (config?.target === "openapi-3.0") jsonSchema.enum = [null];
|
|
else jsonSchema.type = "null";
|
|
break;
|
|
case "number":
|
|
jsonSchema.type = "number";
|
|
break;
|
|
case "string":
|
|
jsonSchema.type = "string";
|
|
break;
|
|
case "array":
|
|
jsonSchema.type = "array";
|
|
jsonSchema.items = convertSchema({}, valibotSchema.item, config, context);
|
|
break;
|
|
case "tuple":
|
|
case "tuple_with_rest":
|
|
case "loose_tuple":
|
|
case "strict_tuple":
|
|
jsonSchema.type = "array";
|
|
if (config?.target === "openapi-3.0") {
|
|
jsonSchema.items = { anyOf: [] };
|
|
jsonSchema.minItems = valibotSchema.items.length;
|
|
for (const item of valibotSchema.items) jsonSchema.items.anyOf.push(convertSchema({}, item, config, context));
|
|
if (valibotSchema.type === "tuple_with_rest") jsonSchema.items.anyOf.push(convertSchema({}, valibotSchema.rest, config, context));
|
|
else if (valibotSchema.type === "strict_tuple" || valibotSchema.type === "tuple") jsonSchema.maxItems = valibotSchema.items.length;
|
|
} else if (config?.target === "draft-2020-12") {
|
|
jsonSchema.prefixItems = [];
|
|
jsonSchema.minItems = valibotSchema.items.length;
|
|
for (const item of valibotSchema.items) jsonSchema.prefixItems.push(convertSchema({}, item, config, context));
|
|
if (valibotSchema.type === "tuple_with_rest") jsonSchema.items = convertSchema({}, valibotSchema.rest, config, context);
|
|
else if (valibotSchema.type === "strict_tuple") jsonSchema.items = false;
|
|
} else {
|
|
jsonSchema.items = [];
|
|
jsonSchema.minItems = valibotSchema.items.length;
|
|
for (const item of valibotSchema.items) jsonSchema.items.push(convertSchema({}, item, config, context));
|
|
if (valibotSchema.type === "tuple_with_rest") jsonSchema.additionalItems = convertSchema({}, valibotSchema.rest, config, context);
|
|
else if (valibotSchema.type === "strict_tuple") jsonSchema.additionalItems = false;
|
|
}
|
|
break;
|
|
case "object":
|
|
case "object_with_rest":
|
|
case "loose_object":
|
|
case "strict_object":
|
|
jsonSchema.type = "object";
|
|
jsonSchema.properties = {};
|
|
jsonSchema.required = [];
|
|
for (const key in valibotSchema.entries) {
|
|
const entry = valibotSchema.entries[key];
|
|
jsonSchema.properties[key] = convertSchema({}, entry, config, context);
|
|
if (entry.type !== "exact_optional" && entry.type !== "nullish" && entry.type !== "optional") jsonSchema.required.push(key);
|
|
}
|
|
if (valibotSchema.type === "object_with_rest") jsonSchema.additionalProperties = convertSchema({}, valibotSchema.rest, config, context);
|
|
else if (valibotSchema.type === "strict_object") jsonSchema.additionalProperties = false;
|
|
break;
|
|
case "record":
|
|
if (config?.target === "openapi-3.0" && "pipe" in valibotSchema.key) errors = addError(errors, "The \"record\" schema with a schema for the key that contains a \"pipe\" cannot be converted to JSON Schema.");
|
|
if (valibotSchema.key.type !== "string") errors = addError(errors, `The "record" schema with the "${valibotSchema.key.type}" schema for the key cannot be converted to JSON Schema.`);
|
|
jsonSchema.type = "object";
|
|
if (config?.target !== "openapi-3.0") jsonSchema.propertyNames = convertSchema({}, valibotSchema.key, config, context);
|
|
jsonSchema.additionalProperties = convertSchema({}, valibotSchema.value, config, context);
|
|
break;
|
|
case "any":
|
|
case "unknown": break;
|
|
case "nullable":
|
|
case "nullish":
|
|
if (config?.target === "openapi-3.0") {
|
|
const innerSchema = convertSchema({}, valibotSchema.wrapped, config, context);
|
|
Object.assign(jsonSchema, innerSchema);
|
|
jsonSchema.nullable = true;
|
|
} else jsonSchema.anyOf = [convertSchema({}, valibotSchema.wrapped, config, context), { type: "null" }];
|
|
if (valibotSchema.default !== void 0) jsonSchema.default = valibot.getDefault(valibotSchema);
|
|
break;
|
|
case "exact_optional":
|
|
case "optional":
|
|
case "undefinedable":
|
|
jsonSchema = convertSchema(jsonSchema, valibotSchema.wrapped, config, context);
|
|
if (valibotSchema.default !== void 0) jsonSchema.default = valibot.getDefault(valibotSchema);
|
|
break;
|
|
case "literal":
|
|
if (typeof valibotSchema.literal !== "boolean" && typeof valibotSchema.literal !== "number" && typeof valibotSchema.literal !== "string") errors = addError(errors, "The value of the \"literal\" schema is not JSON compatible.");
|
|
if (config?.target === "openapi-3.0") jsonSchema.enum = [valibotSchema.literal];
|
|
else jsonSchema.const = valibotSchema.literal;
|
|
break;
|
|
case "enum":
|
|
jsonSchema.enum = valibotSchema.options;
|
|
break;
|
|
case "picklist":
|
|
if (valibotSchema.options.some((option) => typeof option !== "number" && typeof option !== "string")) errors = addError(errors, "An option of the \"picklist\" schema is not JSON compatible.");
|
|
jsonSchema.enum = valibotSchema.options;
|
|
break;
|
|
case "union":
|
|
jsonSchema.anyOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
|
|
break;
|
|
case "variant":
|
|
jsonSchema.oneOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
|
|
break;
|
|
case "intersect":
|
|
jsonSchema.allOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
|
|
break;
|
|
case "lazy": {
|
|
let wrappedValibotSchema = context.getterMap.get(valibotSchema.getter);
|
|
if (!wrappedValibotSchema) {
|
|
wrappedValibotSchema = valibotSchema.getter(void 0);
|
|
context.getterMap.set(valibotSchema.getter, wrappedValibotSchema);
|
|
}
|
|
let referenceId = context.referenceMap.get(wrappedValibotSchema);
|
|
if (!referenceId) {
|
|
referenceId = `${refCount++}`;
|
|
context.referenceMap.set(wrappedValibotSchema, referenceId);
|
|
context.definitions[referenceId] = convertSchema({}, wrappedValibotSchema, config, context, true);
|
|
}
|
|
jsonSchema.$ref = `#/$defs/${referenceId}`;
|
|
if (config?.overrideRef) {
|
|
const refOverride = config.overrideRef({
|
|
...context,
|
|
referenceId,
|
|
valibotSchema: wrappedValibotSchema,
|
|
jsonSchema
|
|
});
|
|
if (refOverride) jsonSchema.$ref = refOverride;
|
|
}
|
|
break;
|
|
}
|
|
default: errors = addError(errors, `The "${valibotSchema.type}" schema cannot be converted to JSON Schema.`);
|
|
}
|
|
if (config?.overrideSchema) {
|
|
const schemaOverride = config.overrideSchema({
|
|
...context,
|
|
referenceId: context.referenceMap.get(valibotSchema),
|
|
valibotSchema,
|
|
jsonSchema,
|
|
errors
|
|
});
|
|
if (schemaOverride) return { ...schemaOverride };
|
|
}
|
|
if (errors) for (const message of errors) handleError(message, config);
|
|
return jsonSchema;
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/storages/globalDefs/globalDefs.ts
|
|
let store;
|
|
/**
|
|
* Adds new definitions to the global schema definitions.
|
|
*
|
|
* @param definitions The schema definitions.
|
|
*
|
|
* @beta
|
|
*/
|
|
function addGlobalDefs(definitions) {
|
|
store = {
|
|
...store ?? {},
|
|
...definitions
|
|
};
|
|
}
|
|
/**
|
|
* Returns the current global schema definitions.
|
|
*
|
|
* @returns The schema definitions.
|
|
*
|
|
* @beta
|
|
*/
|
|
function getGlobalDefs() {
|
|
return store;
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/functions/toJsonSchema/toJsonSchema.ts
|
|
/**
|
|
* Converts a Valibot schema to the JSON Schema format.
|
|
*
|
|
* @param schema The Valibot schema object.
|
|
* @param config The JSON Schema configuration.
|
|
*
|
|
* @returns The converted JSON Schema.
|
|
*/
|
|
function toJsonSchema(schema, config) {
|
|
const context = {
|
|
definitions: {},
|
|
referenceMap: /* @__PURE__ */ new Map(),
|
|
getterMap: /* @__PURE__ */ new Map()
|
|
};
|
|
const definitions = config?.definitions ?? getGlobalDefs();
|
|
if (definitions) {
|
|
for (const key in definitions) context.referenceMap.set(definitions[key], key);
|
|
for (const key in definitions) context.definitions[key] = convertSchema({}, definitions[key], config, context, true);
|
|
}
|
|
const jsonSchema = convertSchema({}, schema, config, context);
|
|
const target = config?.target ?? "draft-07";
|
|
if (target === "draft-2020-12") jsonSchema.$schema = "https://json-schema.org/draft/2020-12/schema";
|
|
else if (target === "draft-07") jsonSchema.$schema = "http://json-schema.org/draft-07/schema#";
|
|
if (context.referenceMap.size) jsonSchema.$defs = context.definitions;
|
|
return jsonSchema;
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/functions/toJsonSchemaDefs/toJsonSchemaDefs.ts
|
|
/**
|
|
* Converts Valibot schema definitions to JSON Schema definitions.
|
|
*
|
|
* @param definitions The Valibot schema definitions.
|
|
* @param config The JSON Schema configuration.
|
|
*
|
|
* @returns The converted JSON Schema definitions.
|
|
*/
|
|
function toJsonSchemaDefs(definitions, config) {
|
|
const context = {
|
|
definitions: {},
|
|
referenceMap: /* @__PURE__ */ new Map(),
|
|
getterMap: /* @__PURE__ */ new Map()
|
|
};
|
|
for (const key in definitions) context.referenceMap.set(definitions[key], key);
|
|
for (const key in definitions) context.definitions[key] = convertSchema({}, definitions[key], config, context, true);
|
|
return context.definitions;
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/functions/toStandardJsonSchema/toStandardJsonSchema.ts
|
|
const SUPPORTED_TARGETS = [
|
|
"draft-07",
|
|
"draft-2020-12",
|
|
"openapi-3.0"
|
|
];
|
|
/**
|
|
* Converts a Valibot schema to the Standard JSON Schema format.
|
|
*
|
|
* @param schema The Valibot schema object.
|
|
*
|
|
* @returns The Standard JSON Schema.
|
|
*/
|
|
function toStandardJsonSchema(schema) {
|
|
return { "~standard": {
|
|
...schema["~standard"],
|
|
jsonSchema: {
|
|
input(options) {
|
|
if (SUPPORTED_TARGETS.includes(options.target)) return toJsonSchema(schema, {
|
|
typeMode: "input",
|
|
target: options.target,
|
|
...options.libraryOptions
|
|
});
|
|
throw new Error(`Unsupported target: ${options.target}`);
|
|
},
|
|
output(options) {
|
|
if (SUPPORTED_TARGETS.includes(options.target)) return toJsonSchema(schema, {
|
|
typeMode: "output",
|
|
target: options.target,
|
|
...options.libraryOptions
|
|
});
|
|
throw new Error(`Unsupported target: ${options.target}`);
|
|
}
|
|
}
|
|
} };
|
|
}
|
|
|
|
//#endregion
|
|
exports.addGlobalDefs = addGlobalDefs;
|
|
exports.getGlobalDefs = getGlobalDefs;
|
|
exports.toJsonSchema = toJsonSchema;
|
|
exports.toJsonSchemaDefs = toJsonSchemaDefs;
|
|
exports.toStandardJsonSchema = toStandardJsonSchema; |