@takeshape/json-schema 11.52.0 → 11.55.0

package/dist/utils/__tests__/type-utils.test.js

@@ -0,0 +1,143 @@
+import { describe, expect, it } from 'vitest';
+import { isAllOfSchema, isAnyOfSchema, isArraySchema, isEnumSchema, isListSchema, isObjectSchema, isOneOfSchema, isPropertySchema, isRefSchema, isSchema, isTupleSchema, isUnionSchema } from "../type-utils.js";
+describe('isSchema', () => {
+    it('should return true for valid JSONSchema7', () => {
+        const schema = { type: 'object' };
+        expect(isSchema(schema)).toBe(true);
+    });
+    it('should return false for boolean schema', () => {
+        const schema = false;
+        expect(isSchema(schema)).toBe(false);
+    });
+});
+describe('isOneOfSchema', () => {
+    it('should return true for oneOf schema', () => {
+        const schema = { oneOf: [{ type: 'string' }] };
+        expect(isOneOfSchema(schema)).toBe(true);
+    });
+    it('should return false for non-oneOf schema', () => {
+        const schema = { type: 'string' };
+        expect(isOneOfSchema(schema)).toBe(false);
+    });
+});
+describe('isAnyOfSchema', () => {
+    it('should return true for anyOf schema', () => {
+        const schema = { anyOf: [{ type: 'string' }] };
+        expect(isAnyOfSchema(schema)).toBe(true);
+    });
+    it('should return false for non-anyOf schema', () => {
+        const schema = { type: 'string' };
+        expect(isAnyOfSchema(schema)).toBe(false);
+    });
+});
+describe('isAllOfSchema', () => {
+    it('should return true for allOf schema', () => {
+        const schema = { allOf: [{ type: 'string' }] };
+        expect(isAllOfSchema(schema)).toBe(true);
+    });
+    it('should return false for non-allOf schema', () => {
+        const schema = { type: 'string' };
+        expect(isAllOfSchema(schema)).toBe(false);
+    });
+});
+describe('isUnionSchema', () => {
+    it('should return true for allOf/anyOf/oneOf schema', () => {
+        expect(isUnionSchema({ allOf: [{ type: 'string' }] })).toBe(true);
+        expect(isUnionSchema({ anyOf: [{ type: 'string' }] })).toBe(true);
+        expect(isUnionSchema({ oneOf: [{ type: 'string' }] })).toBe(true);
+    });
+    it('should return false for non-allOf/anyOf/oneOf schema', () => {
+        const schema = { type: 'string' };
+        expect(isUnionSchema(schema)).toBe(false);
+    });
+});
+describe('isObjectSchema', () => {
+    it('should return true for object schema', () => {
+        const schema = { type: 'object' };
+        expect(isObjectSchema(schema)).toBe(true);
+    });
+    it('should return false for non-object schema', () => {
+        const schema = { type: 'string' };
+        expect(isObjectSchema(schema)).toBe(false);
+    });
+});
+describe('isPropertySchema', () => {
+    it('should return true for an object schema with properties', () => {
+        const schema = { type: 'object', properties: {} };
+        expect(isPropertySchema(schema)).toBe(true);
+    });
+    it('should return false for non-property schema', () => {
+        const schema = { type: 'object' };
+        expect(isPropertySchema(schema)).toBe(false);
+    });
+});
+describe('isRefSchema', () => {
+    it('should return true for a schema with $ref', () => {
+        const schema = { $ref: '#/definitions/definition' };
+        expect(isRefSchema(schema)).toBe(true);
+    });
+    it('should return false for non-$ref schema', () => {
+        const schema = { type: 'string' };
+        expect(isRefSchema(schema)).toBe(false);
+    });
+});
+describe('isEnumSchema', () => {
+    it('should return true for a schema with enums', () => {
+        const schema = { enum: ['value1', 'value2'] };
+        expect(isEnumSchema(schema)).toBe(true);
+    });
+    it('should return false for non-enum schema', () => {
+        const schema = { type: 'string' };
+        expect(isEnumSchema(schema)).toBe(false);
+    });
+});
+describe('isArraySchema', () => {
+    it('should return true for an array schema', () => {
+        const schema = { type: 'array' };
+        expect(isArraySchema(schema)).toBe(true);
+    });
+    it('should return false for non-array schema', () => {
+        const schema = { type: 'string' };
+        expect(isArraySchema(schema)).toBe(false);
+    });
+});
+describe('isListSchema', () => {
+    it('should return true for an array list schema', () => {
+        const schema = {
+            type: 'array',
+            items: { type: 'string' }
+        };
+        expect(isListSchema(schema)).toBe(true);
+    });
+    it('should return false for partial list schema', () => {
+        const schema = { type: 'array' };
+        expect(isListSchema(schema)).toBe(false);
+    });
+    it('should return false for a tuple schema', () => {
+        const schema = {
+            type: 'array',
+            items: [{ type: 'string' }]
+        };
+        expect(isListSchema(schema)).toBe(false);
+    });
+});
+describe('isTupleSchema', () => {
+    it('should return true for tuple schema', () => {
+        const schema = {
+            type: 'array',
+            items: [{ type: 'string' }]
+        };
+        expect(isTupleSchema(schema)).toBe(true);
+    });
+    it('should return false for partial array schema', () => {
+        const schema = { type: 'array' };
+        expect(isTupleSchema(schema)).toBe(false);
+    });
+    it('should return false for an array list schema', () => {
+        const schema = {
+            type: 'array',
+            items: { type: 'string' }
+        };
+        expect(isTupleSchema(schema)).toBe(false);
+    });
+});

package/dist/utils/constants.d.ts

@@ -1,3 +1,2 @@
 import type { JSONSchema7 } from 'json-schema';
 export declare const jsonSchema7Keys: Array<keyof JSONSchema7>;
-//# sourceMappingURL=constants.d.ts.map

package/dist/utils/constants.js

@@ -1,7 +1,49 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.jsonSchema7Keys = void 0;
-const jsonSchema7Keys = exports.jsonSchema7Keys = ['$id', '$schema', '$ref', '$comment', 'title', 'description', 'default', 'readOnly', 'writeOnly', 'examples', 'multipleOf', 'maximum', 'exclusiveMaximum', 'minimum', 'exclusiveMinimum', 'maxLength', 'minLength', 'pattern', 'additionalItems', 'items', 'maxItems', 'minItems', 'uniqueItems', 'contains', 'maxProperties', 'minProperties', 'required', 'properties', 'patternProperties', 'additionalProperties', 'dependencies', 'propertyNames', 'const', 'enum', 'type', 'format', 'contentMediaType', 'contentEncoding', 'if', 'then', 'else', 'allOf', 'anyOf', 'oneOf', 'not', 'definitions', '$defs'];
+export const jsonSchema7Keys = [
+    '$id',
+    '$schema',
+    '$ref',
+    '$comment',
+    'title',
+    'description',
+    'default',
+    'readOnly',
+    'writeOnly',
+    'examples',
+    'multipleOf',
+    'maximum',
+    'exclusiveMaximum',
+    'minimum',
+    'exclusiveMinimum',
+    'maxLength',
+    'minLength',
+    'pattern',
+    'additionalItems',
+    'items',
+    'maxItems',
+    'minItems',
+    'uniqueItems',
+    'contains',
+    'maxProperties',
+    'minProperties',
+    'required',
+    'properties',
+    'patternProperties',
+    'additionalProperties',
+    'dependencies',
+    'propertyNames',
+    'const',
+    'enum',
+    'type',
+    'format',
+    'contentMediaType',
+    'contentEncoding',
+    'if',
+    'then',
+    'else',
+    'allOf',
+    'anyOf',
+    'oneOf',
+    'not',
+    'definitions',
+    '$defs'
+];

package/dist/utils/index.d.ts

@@ -1,5 +1,4 @@
-export * from './type-utils';
-export * from './types';
-export * from './references';
-export * from './keys';
-//# sourceMappingURL=index.d.ts.map
+export * from './type-utils.ts';
+export * from './types.ts';
+export * from './references.ts';
+export * from './keys.ts';

package/dist/utils/index.js

@@ -1,49 +1,4 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _typeUtils = require("./type-utils");
-Object.keys(_typeUtils).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _typeUtils[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _typeUtils[key];
-    }
-  });
-});
-var _types = require("./types");
-Object.keys(_types).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _types[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _types[key];
-    }
-  });
-});
-var _references = require("./references");
-Object.keys(_references).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _references[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _references[key];
-    }
-  });
-});
-var _keys = require("./keys");
-Object.keys(_keys).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _keys[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _keys[key];
-    }
-  });
-});
+export * from "./type-utils.js";
+export * from "./types.js";
+export * from "./references.js";
+export * from "./keys.js";

package/dist/utils/keys.d.ts

@@ -3,4 +3,3 @@ import type { JSONSchema7 } from 'json-schema';
  * Picks only valid JSON Schema 7 keys from the given schema.
  */
 export declare function pickJSONSchema7(schema: JSONSchema7): JSONSchema7;
-//# sourceMappingURL=keys.d.ts.map

package/dist/utils/keys.js

@@ -1,15 +1,8 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.pickJSONSchema7 = pickJSONSchema7;
-var _pick = _interopRequireDefault(require("lodash/pick"));
-var _constants = require("./constants");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+import pick from 'lodash/pick.js';
+import { jsonSchema7Keys } from "./constants.js";
 /**
  * Picks only valid JSON Schema 7 keys from the given schema.
  */
-function pickJSONSchema7(schema) {
-  return (0, _pick.default)(schema, _constants.jsonSchema7Keys);
-}
+export function pickJSONSchema7(schema) {
+    return pick(schema, jsonSchema7Keys);
+}

package/dist/utils/references.d.ts

@@ -3,4 +3,3 @@ import type { JSONSchema7Definition } from 'json-schema';
  * Get all the definitions that are referenced by other definitions.
  */
 export declare function getReferenceMap(definitions: Record<string, JSONSchema7Definition>): Map<string, Set<string>>;
-//# sourceMappingURL=references.d.ts.map

package/dist/utils/references.js

@@ -1,72 +1,71 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getReferenceMap = getReferenceMap;
-var _typeUtils = require("./type-utils");
+import { isAllOfSchema, isAnyOfSchema, isOneOfSchema, isPropertySchema, isRefSchema, isSchema } from "./type-utils.js";
 const SCHEMA_DEFINITION_PREFIX = ['#/definitions/', '#/$defs/'];
 function collectRef(def, key, collect) {
-  if ((0, _typeUtils.isRefSchema)(def)) {
-    collect(def.$ref, key);
-  } else if ((0, _typeUtils.isSchema)(def)) {
-    collectRefs(def, key, collect);
-  }
+    if (isRefSchema(def)) {
+        collect(def.$ref, key);
+    }
+    else if (isSchema(def)) {
+        collectRefs(def, key, collect);
+    }
 }
 function collectRefs(def, key, collect) {
-  if ((0, _typeUtils.isPropertySchema)(def)) {
-    for (const d of Object.values(def.properties)) {
-      collectRef(d, key, collect);
+    if (isPropertySchema(def)) {
+        for (const d of Object.values(def.properties)) {
+            collectRef(d, key, collect);
+        }
+    }
+    else if (isAllOfSchema(def)) {
+        for (const d of def.allOf) {
+            collectRef(d, key, collect);
+        }
     }
-  } else if ((0, _typeUtils.isAllOfSchema)(def)) {
-    for (const d of def.allOf) {
-      collectRef(d, key, collect);
+    else if (isAnyOfSchema(def)) {
+        for (const d of def.anyOf) {
+            collectRef(d, key, collect);
+        }
     }
-  } else if ((0, _typeUtils.isAnyOfSchema)(def)) {
-    for (const d of def.anyOf) {
-      collectRef(d, key, collect);
+    else if (isOneOfSchema(def)) {
+        for (const d of def.oneOf) {
+            collectRef(d, key, collect);
+        }
     }
-  } else if ((0, _typeUtils.isOneOfSchema)(def)) {
-    for (const d of def.oneOf) {
-      collectRef(d, key, collect);
+    else if (Array.isArray(def.items)) {
+        for (const d of def.items) {
+            collectRef(d, key, collect);
+        }
     }
-  } else if (Array.isArray(def.items)) {
-    for (const d of def.items) {
-      collectRef(d, key, collect);
+    else if (def.items) {
+        if (isSchema(def.items) && isRefSchema(def.items)) {
+            collect(def.items.$ref, key);
+        }
     }
-  } else if (def.items) {
-    if ((0, _typeUtils.isSchema)(def.items) && (0, _typeUtils.isRefSchema)(def.items)) {
-      collect(def.items.$ref, key);
+    else if (isRefSchema(def)) {
+        collect(def.$ref, key);
     }
-  } else if ((0, _typeUtils.isRefSchema)(def)) {
-    collect(def.$ref, key);
-  }
 }
-
 /**
  * Get all the definitions that are referenced by other definitions.
  */
-function getReferenceMap(definitions) {
-  const references = new Map();
-  const addToReferenceMap = (ref, key) => {
-    const refKey = ref.replace(SCHEMA_DEFINITION_PREFIX[0], '').replace(SCHEMA_DEFINITION_PREFIX[1], '');
-    const refSet = references.get(key) ?? new Set();
-
-    // Circular reference
-    if (key === refKey) {
-      return;
+export function getReferenceMap(definitions) {
+    const references = new Map();
+    const addToReferenceMap = (ref, key) => {
+        const refKey = ref.replace(SCHEMA_DEFINITION_PREFIX[0], '').replace(SCHEMA_DEFINITION_PREFIX[1], '');
+        const refSet = references.get(key) ?? new Set();
+        // Circular reference
+        if (key === refKey) {
+            return;
+        }
+        refSet.add(refKey);
+        references.set(key, refSet);
+        const refDef = definitions[refKey];
+        if (refDef && isSchema(refDef)) {
+            collectRefs(refDef, key, addToReferenceMap);
+        }
+    };
+    for (const [key, def] of Object.entries(definitions)) {
+        if (isSchema(def)) {
+            collectRefs(def, key, addToReferenceMap);
+        }
     }
-    refSet.add(refKey);
-    references.set(key, refSet);
-    const refDef = definitions[refKey];
-    if (refDef && (0, _typeUtils.isSchema)(refDef)) {
-      collectRefs(refDef, key, addToReferenceMap);
-    }
-  };
-  for (const [key, def] of Object.entries(definitions)) {
-    if ((0, _typeUtils.isSchema)(def)) {
-      collectRefs(def, key, addToReferenceMap);
-    }
-  }
-  return references;
-}
+    return references;
+}

package/dist/utils/type-utils.d.ts

@@ -1,5 +1,5 @@
 import type { JSONSchema7, JSONSchema7Definition } from 'json-schema';
-import type { AllOfSchema, AnyOfSchema, ArraySchema, EnumSchema, ListSchema, ObjectSchema, OneOfSchema, PropertySchema, RefSchema, TupleSchema } from './types';
+import type { AllOfSchema, AnyOfSchema, ArraySchema, EnumSchema, ListSchema, ObjectSchema, OneOfSchema, PropertySchema, RefSchema, TupleSchema } from './types.ts';
 export declare function isSchema(schema: JSONSchema7Definition): schema is JSONSchema7;
 export declare function isOneOfSchema(schema: JSONSchema7Definition): schema is OneOfSchema;
 export declare function isAnyOfSchema(schema: JSONSchema7Definition): schema is AnyOfSchema;
@@ -12,4 +12,3 @@ export declare function isListSchema(schema: JSONSchema7Definition): schema is L
 export declare function isTupleSchema(schema: JSONSchema7Definition): schema is TupleSchema;
 export declare function isEnumSchema(schema: JSONSchema7Definition): schema is EnumSchema;
 export declare function isRefSchema(schema: JSONSchema7Definition): schema is RefSchema;
-//# sourceMappingURL=type-utils.d.ts.map

package/dist/utils/type-utils.js

@@ -1,53 +1,36 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isAllOfSchema = isAllOfSchema;
-exports.isAnyOfSchema = isAnyOfSchema;
-exports.isArraySchema = isArraySchema;
-exports.isEnumSchema = isEnumSchema;
-exports.isListSchema = isListSchema;
-exports.isObjectSchema = isObjectSchema;
-exports.isOneOfSchema = isOneOfSchema;
-exports.isPropertySchema = isPropertySchema;
-exports.isRefSchema = isRefSchema;
-exports.isSchema = isSchema;
-exports.isTupleSchema = isTupleSchema;
-exports.isUnionSchema = isUnionSchema;
-function isSchema(schema) {
-  return typeof schema !== 'boolean';
-}
-function isOneOfSchema(schema) {
-  return isSchema(schema) && Array.isArray(schema.oneOf);
-}
-function isAnyOfSchema(schema) {
-  return isSchema(schema) && Array.isArray(schema.anyOf);
-}
-function isAllOfSchema(schema) {
-  return isSchema(schema) && Array.isArray(schema.allOf);
-}
-function isUnionSchema(schema) {
-  return isOneOfSchema(schema) || isAnyOfSchema(schema) || isAllOfSchema(schema);
-}
-function isObjectSchema(schema) {
-  return isSchema(schema) && schema.type === 'object';
-}
-function isPropertySchema(schema) {
-  return isObjectSchema(schema) && typeof schema.properties === 'object';
-}
-function isArraySchema(schema) {
-  return isSchema(schema) && schema.type === 'array';
-}
-function isListSchema(schema) {
-  return isArraySchema(schema) && typeof schema.items === 'object' && !Array.isArray(schema.items);
-}
-function isTupleSchema(schema) {
-  return isArraySchema(schema) && Array.isArray(schema.items);
-}
-function isEnumSchema(schema) {
-  return Boolean(isSchema(schema) && schema.enum);
-}
-function isRefSchema(schema) {
-  return Boolean(isSchema(schema) && schema.$ref);
-}
+export function isSchema(schema) {
+    return typeof schema !== 'boolean';
+}
+export function isOneOfSchema(schema) {
+    return isSchema(schema) && Array.isArray(schema.oneOf);
+}
+export function isAnyOfSchema(schema) {
+    return isSchema(schema) && Array.isArray(schema.anyOf);
+}
+export function isAllOfSchema(schema) {
+    return isSchema(schema) && Array.isArray(schema.allOf);
+}
+export function isUnionSchema(schema) {
+    return isOneOfSchema(schema) || isAnyOfSchema(schema) || isAllOfSchema(schema);
+}
+export function isObjectSchema(schema) {
+    return isSchema(schema) && schema.type === 'object';
+}
+export function isPropertySchema(schema) {
+    return isObjectSchema(schema) && typeof schema.properties === 'object';
+}
+export function isArraySchema(schema) {
+    return isSchema(schema) && schema.type === 'array';
+}
+export function isListSchema(schema) {
+    return isArraySchema(schema) && typeof schema.items === 'object' && !Array.isArray(schema.items);
+}
+export function isTupleSchema(schema) {
+    return isArraySchema(schema) && Array.isArray(schema.items);
+}
+export function isEnumSchema(schema) {
+    return Boolean(isSchema(schema) && schema.enum);
+}
+export function isRefSchema(schema) {
+    return Boolean(isSchema(schema) && schema.$ref);
+}

package/dist/utils/types.d.ts

@@ -63,4 +63,3 @@ export type OpenAIRootSchema = OpenAISchema & {
         [key: string]: OpenAISchema;
     };
 };
-//# sourceMappingURL=types.d.ts.map

package/dist/utils/types.js

@@ -1,5 +1 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takeshape/json-schema",
-  "version": "11.52.0",
+  "version": "11.55.0",
   "description": "JSON Schema validator",
   "homepage": "https://www.takeshape.io",
   "repository": {
@@ -9,39 +9,36 @@
   },
   "license": "UNLICENSED",
   "author": "asprouse",
+  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./es/index.js",
-      "require": "./dist/index.js",
+      "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
     "./converters": {
       "types": "./dist/converters/index.d.ts",
-      "import": "./es/converters/index.js",
-      "require": "./dist/converters/index.js",
+      "import": "./dist/converters/index.js",
       "default": "./dist/converters/index.js"
     },
     "./utils": {
       "types": "./dist/utils/index.d.ts",
-      "import": "./es/utils/index.js",
-      "require": "./dist/utils/index.js",
+      "import": "./dist/utils/index.js",
       "default": "./dist/utils/index.js"
     }
   },
   "main": "dist/index.js",
-  "module": "es/index.js",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "dist",
-    "es"
+    "dist"
   ],
   "dependencies": {
-    "ajv": "^8.12.0",
-    "ajv-formats": "^2.1.1",
+    "ajv": "8.13.0",
+    "ajv-formats": "3.0.1",
     "lodash": "^4.17.21",
     "minimatch": "^3.0.4",
-    "@takeshape/util": "11.52.0"
+    "@takeshape/util": "11.55.0"
   },
   "devDependencies": {
     "@types/json-schema": "^7.0.7",
@@ -52,25 +49,21 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "pnpm build:js && pnpm build:es && pnpm build:types && pnpm build:copy",
+    "build": "tsc --build tsconfig.build.json",
     "prebuild:ci": "pnpm clean",
-    "build:ci": "pnpm build:js && pnpm build:es && pnpm build:types:ci && pnpm build:copy",
-    "build:copy": "cp -rf build/src/* dist/",
-    "build:es": "cross-env BABEL_MODULES=es babel src --out-dir es --extensions \".js,.ts\" --ignore '**/__tests__'",
-    "build:js": "cross-env BABEL_MODULES=commonjs babel src --out-dir dist --extensions \".js,.ts\" --ignore '**/__tests__'",
-    "build:types": "tsc --emitDeclarationOnly --project tsconfig.build.json",
-    "build:types:ci": "mkdir -p  \"${GITHUB_WORKSPACE}/typecheck-results/${npm_package_name#*\\/}\" && tsc --emitDeclarationOnly --project tsconfig.build.json --pretty false | typescript-jest-junit-reporter | tee \"${GITHUB_WORKSPACE}/typecheck-results/${npm_package_name#*\\/}/typescript-results.xml\"",
-    "clean": "del-cli dist es build *.tsbuildinfo",
+    "build:ci": "pnpm build --noCheck",
+    "clean": "del-cli dist coverage *.tsbuildinfo",
     "lint": "pnpm lint:biome && pnpm lint:eslint",
     "lint:biome": "biome check",
     "lint:eslint": "eslint src -c ../../eslint.config.mjs",
-    "lint:ci": "pnpm lint:ci:biome",
+    "lint:ci": "pnpm lint:ci:biome; pnpm lint:ci:eslint",
     "lint:ci:biome": "mkdir -p \"${GITHUB_WORKSPACE}/test-results/${npm_package_name#*\\/}\" && biome check --diagnostic-level error --reporter=junit > \"${GITHUB_WORKSPACE}/test-results/${npm_package_name#*\\/}/biome-results.xml\"",
     "lint:ci:eslint": "pnpm lint:eslint --quiet --format json -o \"${GITHUB_WORKSPACE}/test-results/${npm_package_name#*\\/}/eslint-results.json\"",
-    "test": "jest",
+    "test": "TZ=UTC vitest run",
     "test-changed": "pnpm run test --changedSince=master",
-    "test:ci": "JEST_JUNIT_OUTPUT_DIR=\"${GITHUB_WORKSPACE}/test-results/${npm_package_name#*\\/}\" JEST_JUNIT_OUTPUT_NAME=\"jest-results.xml\" jest --silent --ci --coverageDirectory=\"${GITHUB_WORKSPACE}/coverage/${npm_package_name#*\\/}\" --reporters=default  --reporters=jest-junit --maxWorkers=4",
+    "test:ci": "TZ=UTC vitest run --reporter=default --reporter=junit --outputFile=\"${GITHUB_WORKSPACE}/test-results/${npm_package_name#*\\/}/vitest-results.xml\" --coverage.enabled --coverage.reportsDirectory=\"${GITHUB_WORKSPACE}/coverage/${npm_package_name#*\\/}\"",
     "todo": "leasot 'src/**/*.{js,jsx,ts,tsx}'",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "typecheck:ci": "mkdir -p  \"${GITHUB_WORKSPACE}/test-results/${npm_package_name#*\\/}\" && tsc --noEmit --project tsconfig.build.json --pretty false | typescript-jest-junit-reporter | tee \"${GITHUB_WORKSPACE}/test-results/${npm_package_name#*\\/}/typescript-results.xml\""
   }
 }

package/dist/converters/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/converters/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/converters/schema-converter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-converter.d.ts","sourceRoot":"","sources":["../../../src/converters/schema-converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAA0C,MAAM,aAAa,CAAC;AA2BvF,MAAM,MAAM,qBAAqB,GAAG;IAClC,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,EAAE,qBAAqB,CAAC;CAC9B,CAAC;AAEF,oBAAY,sBAAsB;IAChC,MAAM,WAAW;IACjB,UAAU,gBAAgB;CAC3B;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC;;OAEG;IACH,MAAM,CAAC,EAAE,sBAAsB,CAAC;IAChC;;OAEG;IACH,yBAAyB,CAAC,EAAE,MAAM,EAAE,CAAC;IACrC;;OAEG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAeF,qBAAa,eAAe;;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAM;IACxB,KAAK,EAAE,qBAAqB,CAIjC;IAeF,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,GAAE,uBAA4B;IAIzE,SAAS,aAAa,cAAc,EAAE,WAAW,EAAE,OAAO,GAAE,uBAA4B;IA4BxF,OAAO,CAAC,GAAG;IAmEX,OAAO,CAAC,aAAa;IAmFrB,OAAO,CAAC,kBAAkB;IAe1B,OAAO,CAAC,gBAAgB;IAcxB,OAAO,CAAC,kBAAkB;IAmB1B,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,WAAW;IAqBnB,OAAO,CAAC,gBAAgB;IAyBxB,OAAO,CAAC,mBAAmB;IA4C3B,OAAO,CAAC,mBAAmB;IA6D3B,OAAO,CAAC,kBAAkB;IA8C1B,OAAO,CAAC,2BAA2B;IAgBnC,OAAO,CAAC,kBAAkB;IAe1B,OAAO,CAAC,kBAAkB;IAqB1B,OAAO,CAAC,kBAAkB;IAe1B,OAAO,CAAC,gBAAgB;IA6CxB,OAAO,CAAC,iBAAiB;IAiEzB,OAAO,CAAC,wBAAwB;CAiEjC"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}