@automatons/tools 1.0.218 → 2.0.1

package/index.d.ts

@@ -1,13 +1,341 @@
-export * from './values';
-export * from './types';
-export * from './utils';
-export declare type Setting = {
+type Method = 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace';
+
+interface Openapi {
+    openapi: string;
+    info: OpenapiInfo;
+    servers?: OpenapiServer[];
+    tags?: OpenapiTag[];
+    paths: OpenapiMap<OpenapiPath>;
+    components?: OpenapiComponents;
+    security?: OpenapiSecurity[];
+    externalDocs?: OpenapiExternalDocument;
+}
+interface OpenapiMap<T> {
+    [key: string]: T;
+}
+interface OpenapiInfo {
+    title: string;
+    version: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: OpenapiInfoContact;
+    license?: OpenapiInfoLicense;
+}
+interface OpenapiInfoContact {
+    name: string;
+    url?: string;
+}
+interface OpenapiInfoLicense {
+    name: string;
+    url?: string;
+}
+interface OpenapiServer {
+    url: string;
+    'x-name'?: string;
+    description?: string;
+    variables?: OpenapiMap<OpenapiServerVariable>;
+}
+interface OpenapiServerVariable {
+    default: string;
+    description?: string;
+    enum: string[];
+}
+interface OpenapiExternalDocument {
+    url: string;
+    description?: string;
+}
+interface OpenapiTag {
+    name: string;
+    description?: string;
+    externalDocs?: OpenapiExternalDocument;
+}
+interface OpenapiSecurity {
+    [key: string]: string[];
+}
+interface OpenapiPath {
+    '$ref'?: string;
+    get?: OpenapiPathOperation;
+    put?: OpenapiPathOperation;
+    post?: OpenapiPathOperation;
+    delete?: OpenapiPathOperation;
+    options?: OpenapiPathOperation;
+    head?: OpenapiPathOperation;
+    patch?: OpenapiPathOperation;
+    trace?: OpenapiPathOperation;
+    servers?: OpenapiServer[];
+    parameters?: OpenapiParameter[];
+}
+type OpenapiParameter = OpenapiParameterPath | OpenapiParameterQuery | OpenapiParameterHeader | OpenapiParameterCookie | OpenapiReference;
+type OpenapiParameterCommon = {
+    name: string;
+    description?: string;
+    deprecated?: string;
+    explode?: boolean;
+    example?: any;
+    examples?: OpenapiMap<OpenapiExample>;
+} & ({
+    content: OpenapiMap<OpenapiPathMedia>;
+} | {
+    schema: OpenapiSchema;
+});
+type OpenapiParameterPath = {
+    in: 'path';
+    style: 'simple' | 'label' | 'matrix';
+    required: true;
+} & OpenapiParameterCommon;
+type OpenapiParameterQuery = {
+    in: 'query';
+    style: 'form' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+    required?: boolean;
+    allowReserved?: boolean;
+} & OpenapiParameterCommon;
+type OpenapiParameterHeader = {
+    in: 'header';
+    style: 'simple';
+    required?: boolean;
+} & OpenapiParameterCommon;
+type OpenapiParameterCookie = {
+    in: 'cookie';
+    style: 'form';
+    required?: boolean;
+} & OpenapiParameterCommon;
+interface OpenapiPathOperation extends OpenapiPathCommon {
+    operationId: string;
+    tags?: string[];
+    externalDocs?: OpenapiExternalDocument;
+    parameters?: OpenapiParameter[];
+    requestBody?: OpenapiPathRequestBody | OpenapiReference;
+    responses: OpenapiMap<OpenapiPathResponse | OpenapiReference>;
+    callbacks?: OpenapiMap<OpenapiMap<OpenapiPathOperation>>;
+    deprecated?: boolean;
+    security?: OpenapiMap<string[]>[];
+    servers?: OpenapiServer[];
+}
+interface OpenapiPathRequestBody {
+    content: OpenapiMap<OpenapiPathMedia>;
+    description?: string;
+    required?: boolean;
+}
+type OpenapiPathResponse = {
+    description: string;
+    headers?: OpenapiMap<OpenapiPathResponseHeader | OpenapiReference>;
+    content?: OpenapiMap<OpenapiPathMedia>;
+    links?: OpenapiMap<OpenapiPathResponseLink | OpenapiReference>;
+};
+interface OpenapiPathResponseHeader {
+    description?: string;
+    schema?: OpenapiSchema;
+}
+type OpenapiPathMedia = {
+    schema?: OpenapiSchema;
+    encoding?: OpenapiMap<OpenapiPathResponseMediaEncoding>;
+} & ({
+    example?: any;
+} | {
+    examples?: OpenapiMap<OpenapiExample>;
+});
+type OpenapiExample = {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+};
+interface OpenapiPathResponseMediaEncoding {
+    contentType?: string;
+    headers?: OpenapiMap<OpenapiPathResponseHeader | OpenapiReference>;
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+}
+interface OpenapiPathResponseLink {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: OpenapiMap<any>;
+    requestBody?: any;
+    description?: string;
+    server?: OpenapiServer;
+}
+interface OpenapiPathCommon {
+    summary?: string;
+    description?: string;
+}
+interface OpenapiComponents {
+    schemas?: OpenapiMap<OpenapiSchema>;
+    responses?: object;
+    parameters?: object;
+    examples?: object;
+    requestBodies?: object;
+    headers?: object;
+    securitySchemes?: OpenapiMap<OpenapiSecuritySchema>;
+    links?: object;
+    callbacks?: object;
+}
+type OpenapiSchema = OpenapiSchemaString | OpenapiSchemaBoolean | OpenapiSchemaNumber | OpenapiSchemaInteger | OpenapiSchemaObject | OpenapiSchemaArray | OpenapiSchemaAllOf | OpenapiSchemaOneOf | OpenapiSchemaReference;
+type OpenapiSchemaReference = OpenapiReference & OpenapiSchemaCommon;
+interface OpenapiSchemaString extends OpenapiSchemaCommon {
+    type: 'string';
+    format?: 'date' | 'date-time' | 'password' | 'byte' | 'binary' | string;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    enum?: string[];
+}
+interface OpenapiReference extends OpenapiSchemaCommon {
+    '$ref': string;
+}
+interface OpenapiSchemaBoolean extends OpenapiSchemaCommon {
+    type: 'boolean';
+}
+interface OpenapiSchemaNumber extends OpenapiSchemaCommon {
+    type: 'number';
+    format?: 'float' | 'double' | string;
+    enum?: number[];
+    multipleOf?: number;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+}
+interface OpenapiSchemaInteger extends OpenapiSchemaCommon {
+    type: 'integer';
+    format?: 'int32' | 'int64' | string;
+    enum?: number[];
+    multipleOf?: number;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+}
+interface OpenapiSchemaObject extends OpenapiSchemaCommon {
+    type: 'object';
+    required?: string[];
+    minProperties?: number;
+    maxProperties?: number;
+    properties?: OpenapiMap<OpenapiSchema>;
+    additionalProperties?: true | OpenapiSchema;
+}
+interface OpenapiSchemaArray extends OpenapiSchemaCommon {
+    type: 'array';
+    uniqueItems?: boolean;
+    minItems?: number;
+    maxItems?: number;
+    items?: OpenapiSchema;
+}
+interface OpenapiSchemaAllOf extends OpenapiSchemaCommon {
+    allOf: OpenapiSchema[];
+}
+interface OpenapiSchemaOneOf extends OpenapiSchemaCommon {
+    oneOf: OpenapiSchema[];
+    discriminator?: {
+        propertyName: string;
+        mapping?: {
+            [key: string]: string;
+        };
+    };
+}
+interface OpenapiSchemaCommon {
+    title?: string;
+    description?: string;
+    default?: any;
+    nullable?: boolean;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    externalDocs?: OpenapiExternalDocument;
+    deprecated?: boolean;
+    example?: any;
+}
+type OpenapiSecuritySchema = OpenapiSecurityApiKeySchema | OpenapiSecurityHttpSchema | OpenapiSecurityHttpBearerSchema | OpenapiSecurityOAuth2Schema | OpenapiSecurityOpenIdConnectSchema;
+interface OpenapiSecurityApiKeySchema {
+    type: 'apiKey';
+    description?: string;
+    name: string;
+    in: 'query' | 'header' | 'cookie';
+}
+interface OpenapiSecurityHttpSchema {
+    type: 'http';
+    description?: string;
+    scheme: 'basic';
+}
+interface OpenapiSecurityHttpBearerSchema {
+    type: 'http';
+    description?: string;
+    scheme: 'bearer';
+    bearerFormat?: string;
+}
+interface OpenapiSecurityOAuth2Schema {
+    type: 'oauth2';
+    description?: string;
+    flow: {
+        implicit?: OpenapiSecurityOAuthFlow;
+        password?: OpenapiSecurityOAuthFlow;
+        clientCredentials?: OpenapiSecurityOAuthFlow;
+        authorizationCode?: OpenapiSecurityOAuthFlow;
+    };
+}
+interface OpenapiSecurityOAuthFlow {
+    authorizationUrl: string;
+    tokenUrl: string;
+    refreshUrl?: string;
+    scopes: OpenapiMap<string>;
+}
+interface OpenapiSecurityOpenIdConnectSchema {
+    type: 'openIdConnect';
+    description?: string;
+    openIdConnectUrl: string;
+}
+
+type AutomatonContext = {
+    openapi: Openapi;
+    settings: AutomatonSettings;
+};
+type AutomatonSettings = {
+    outDir: string;
+    path: string;
+    openapiPath: string;
+};
+type Automaton = (openapi: Openapi, settings: AutomatonSettings, options?: object) => void | Promise<unknown>;
+
+declare const HTTP_METHODS: Method[];
+
+declare const fetch: <T = Openapi>(url: string, openapiPath?: string) => Promise<T>;
+
+declare const isRef: (schema: any) => schema is OpenapiReference;
+
+declare const hasSchema: (param: OpenapiParameter) => param is OpenapiParameter & {
+    schema: OpenapiSchema;
+};
+declare const hasContent: (param: OpenapiParameter) => param is OpenapiParameter & {
+    content: OpenapiMap<OpenapiPathMedia>;
+};
+declare const isPathParam: (param: OpenapiParameter) => param is OpenapiParameterPath;
+declare const isQueryParam: (param: OpenapiParameter) => param is OpenapiParameterQuery;
+declare const isHeaderParam: (param: OpenapiParameter) => param is OpenapiParameterHeader;
+declare const isCookieParam: (param: OpenapiParameter) => param is OpenapiParameterCookie;
+
+declare const referenceTitle: (schema: OpenapiReference) => string;
+type ReferenceSchema<T = unknown> = (T | OpenapiReference) | (T & OpenapiReference);
+declare const referenceSchema: <T = unknown>(schema: ReferenceSchema<T>, { openapi, settings: { openapiPath } }: AutomatonContext) => Promise<T>;
+
+declare const isSchemaString: (type: OpenapiSchema) => type is OpenapiSchemaString;
+declare const isSchemaNumber: (type: OpenapiSchema) => type is OpenapiSchemaNumber;
+declare const isSchemaInteger: (type: OpenapiSchema) => type is OpenapiSchemaInteger;
+declare const isSchemaBoolean: (type: OpenapiSchema) => type is OpenapiSchemaBoolean;
+declare const isSchemaObject: (type: OpenapiSchema) => type is OpenapiSchemaObject;
+declare const isSchemaArray: (type: OpenapiSchema) => type is OpenapiSchemaArray;
+declare const isSchemaAllOf: (type: OpenapiSchema) => type is OpenapiSchemaAllOf;
+declare const isSchemaOneOf: (type: OpenapiSchema) => type is OpenapiSchemaOneOf;
+declare const isSchemaRef: (type: OpenapiSchema) => type is OpenapiSchemaReference;
+
+declare const isUrl: (url: string) => boolean;
+
+type Setting = {
     openapi: string;
     automatons: AutomatonSetting[];
 };
-export declare type AutomatonSetting = {
+type AutomatonSetting = {
     automaton: string;
     outDir: string;
     options?: object;
 };
-//# sourceMappingURL=index.d.ts.map
+
+export { type Automaton, type AutomatonContext, type AutomatonSetting, type AutomatonSettings, HTTP_METHODS, type Method, type Openapi, type OpenapiComponents, type OpenapiExample, type OpenapiExternalDocument, type OpenapiInfo, type OpenapiInfoContact, type OpenapiInfoLicense, type OpenapiMap, type OpenapiParameter, type OpenapiParameterCommon, type OpenapiParameterCookie, type OpenapiParameterHeader, type OpenapiParameterPath, type OpenapiParameterQuery, type OpenapiPath, type OpenapiPathCommon, type OpenapiPathMedia, type OpenapiPathOperation, type OpenapiPathRequestBody, type OpenapiPathResponse, type OpenapiPathResponseHeader, type OpenapiPathResponseLink, type OpenapiPathResponseMediaEncoding, type OpenapiReference, type OpenapiSchema, type OpenapiSchemaAllOf, type OpenapiSchemaArray, type OpenapiSchemaBoolean, type OpenapiSchemaCommon, type OpenapiSchemaInteger, type OpenapiSchemaNumber, type OpenapiSchemaObject, type OpenapiSchemaOneOf, type OpenapiSchemaReference, type OpenapiSchemaString, type OpenapiSecurity, type OpenapiSecurityApiKeySchema, type OpenapiSecurityHttpBearerSchema, type OpenapiSecurityHttpSchema, type OpenapiSecurityOAuth2Schema, type OpenapiSecurityOAuthFlow, type OpenapiSecurityOpenIdConnectSchema, type OpenapiSecuritySchema, type OpenapiServer, type OpenapiServerVariable, type OpenapiTag, type Setting, fetch, hasContent, hasSchema, isCookieParam, isHeaderParam, isPathParam, isQueryParam, isRef, isSchemaAllOf, isSchemaArray, isSchemaBoolean, isSchemaInteger, isSchemaNumber, isSchemaObject, isSchemaOneOf, isSchemaRef, isSchemaString, isUrl, referenceSchema, referenceTitle };

package/index.js

@@ -1,20 +1,123 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
+// src/values/http.ts
+var HTTP_METHODS = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+
+// src/utils/fetch.ts
+import { readFile } from "fs/promises";
+import { dirname, extname, resolve } from "path";
+import { load } from "js-yaml";
+
+// src/utils/url.ts
+var isUrl = (url) => url.startsWith("http://") || url.startsWith("https://");
+
+// src/utils/fetch.ts
+var fetch = async (url, openapiPath) => parse(await read(url, openapiPath), url);
+var read = async (url, openapiPath) => {
+  if (isUrl(url)) {
+    return fetchText(url);
+  }
+  if (openapiPath && isUrl(openapiPath)) {
+    return fetchText(new URL(url, openapiPath).toString());
+  }
+  const base = openapiPath ? extname(openapiPath) ? dirname(openapiPath) : openapiPath : "";
+  return readFile(resolve(base, url), { encoding: "utf-8" });
+};
+var fetchText = async (url) => {
+  const response = await globalThis.fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+  }
+  return response.text();
+};
+var parse = (data, filePath) => {
+  switch (extname(filePath)) {
+    case ".json":
+      return JSON.parse(data);
+    case ".yml":
+    case ".yaml": {
+      const yaml = load(data);
+      if (typeof yaml === "object") {
+        return yaml;
+      }
+      throw new Error("Unsupported file format");
+    }
+    default:
+      throw new Error("Unsupported file extension");
+  }
+};
+
+// src/utils/openapi.ts
+var isRef = (schema) => Object.hasOwn(schema, "$ref");
+
+// src/utils/parameter.ts
+var hasSchema = (param) => Object.hasOwn(param, "schema");
+var hasContent = (param) => Object.hasOwn(param, "content");
+var isPathParam = (param) => !isRef(param) && param.in === "path";
+var isQueryParam = (param) => !isRef(param) && param.in === "query";
+var isHeaderParam = (param) => !isRef(param) && param.in === "header";
+var isCookieParam = (param) => !isRef(param) && param.in === "cookie";
+
+// src/utils/reference.ts
+import { parse as parse2 } from "path";
+var referenceTitle = (schema) => {
+  const [url = "", path = ""] = schema.$ref.split("#");
+  const paths = path.split("/").slice(1);
+  if (paths.length) {
+    return paths[paths.length - 1];
+  } else if (isUrl(url)) {
+    return parse2(url).name;
+  }
+  throw new Error(`Invalid ref format: ${schema.$ref}
+  Can not extract name.`);
+};
+var referenceSchema = async (schema, { openapi, settings: { openapiPath } }) => {
+  if (!isRef(schema)) return schema;
+  const [url, path] = schema.$ref.split("#");
+  const file = url ? await fetch(url, openapiPath) : openapi;
+  if (!path) {
+    if (!file) {
+      throw new Error(`Invalid ref path ${schema.$ref}`);
     }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+    return file;
+  }
+  const paths = path?.split("/").slice(1);
+  const extractSchema = paths?.reduce((pre, cur) => pre?.[cur], file);
+  if (!extractSchema) {
+    throw new Error(`Invalid ref path ${schema.$ref}`);
+  }
+  return extractSchema;
+};
+
+// src/utils/schema.ts
+var isSchemaString = (type) => type.type === "string";
+var isSchemaNumber = (type) => type.type === "number";
+var isSchemaInteger = (type) => type.type === "integer";
+var isSchemaBoolean = (type) => type.type === "boolean";
+var isSchemaObject = (type) => type.type === "object" || Object.hasOwn(type, "properties");
+var isSchemaArray = (type) => type.type === "array" || Object.hasOwn(type, "items");
+var isSchemaAllOf = (type) => Object.hasOwn(type, "allOf");
+var isSchemaOneOf = (type) => Object.hasOwn(type, "oneOf");
+var isSchemaRef = (type) => Object.hasOwn(type, "$ref");
+export {
+  HTTP_METHODS,
+  fetch,
+  hasContent,
+  hasSchema,
+  isCookieParam,
+  isHeaderParam,
+  isPathParam,
+  isQueryParam,
+  isRef,
+  isSchemaAllOf,
+  isSchemaArray,
+  isSchemaBoolean,
+  isSchemaInteger,
+  isSchemaNumber,
+  isSchemaObject,
+  isSchemaOneOf,
+  isSchemaRef,
+  isSchemaString,
+  isUrl,
+  referenceSchema,
+  referenceTitle
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./values"), exports);
-__exportStar(require("./types"), exports);
-__exportStar(require("./utils"), exports);
 //# sourceMappingURL=index.js.map

package/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,0CAAwB;AACxB,0CAAwB"}
+{"version":3,"sources":["../src/values/http.ts","../src/utils/fetch.ts","../src/utils/url.ts","../src/utils/openapi.ts","../src/utils/parameter.ts","../src/utils/reference.ts","../src/utils/schema.ts"],"sourcesContent":["import {Method} from '../types';\n\nexport const HTTP_METHODS: Method[] = ['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'];\n","import {readFile} from 'node:fs/promises';\nimport {dirname, extname, resolve} from 'node:path';\nimport {load} from 'js-yaml';\nimport {Openapi} from '../types';\nimport {isUrl} from './url';\n\nexport const fetch = async <T = Openapi>(url: string, openapiPath?: string): Promise<T> =>\n  parse(await read(url, openapiPath), url);\n\nconst read = async (url: string, openapiPath?: string): Promise<string> => {\n  if (isUrl(url)) {\n    return fetchText(url);\n  }\n  if (openapiPath && isUrl(openapiPath)) {\n    return fetchText(new URL(url, openapiPath).toString());\n  }\n  const base = openapiPath ? (extname(openapiPath) ? dirname(openapiPath) : openapiPath) : '';\n  return readFile(resolve(base, url), {encoding: 'utf-8'});\n};\n\nconst fetchText = async (url: string): Promise<string> => {\n  const response = await globalThis.fetch(url);\n  if (!response.ok) {\n    throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);\n  }\n  return response.text();\n};\n\nconst parse = <T = Openapi>(data: string, filePath: string): T => {\n  switch (extname(filePath)) {\n    case '.json':\n      return JSON.parse(data);\n    case '.yml':\n    case '.yaml': {\n      const yaml = load(data);\n      if (typeof yaml === 'object') {\n        return yaml as T;\n      }\n      throw new Error('Unsupported file format');\n    }\n    default:\n      throw new Error('Unsupported file extension');\n  }\n};\n","export const isUrl = (url: string) =>\n  url.startsWith('http://') || url.startsWith('https://');\n","import {OpenapiReference} from '../types';\n\nexport const isRef = (schema: any): schema is OpenapiReference => Object.hasOwn(schema, '$ref');\n","import {\n  OpenapiMap,\n  OpenapiParameter,\n  OpenapiParameterCookie,\n  OpenapiParameterHeader,\n  OpenapiParameterPath,\n  OpenapiParameterQuery,\n  OpenapiPathMedia,\n  OpenapiSchema,\n} from '../types';\nimport {isRef} from './openapi';\n\nexport const hasSchema =\n  (param: OpenapiParameter): param is OpenapiParameter & { schema: OpenapiSchema } =>\n    Object.hasOwn(param, 'schema');\nexport const hasContent =\n  (param: OpenapiParameter): param is OpenapiParameter & { content: OpenapiMap<OpenapiPathMedia> } =>\n    Object.hasOwn(param, 'content');\nexport const isPathParam =\n  (param: OpenapiParameter): param is OpenapiParameterPath => !isRef(param) && param.in === 'path';\nexport const isQueryParam =\n  (param: OpenapiParameter): param is OpenapiParameterQuery => !isRef(param) && param.in === 'query';\nexport const isHeaderParam =\n  (param: OpenapiParameter): param is OpenapiParameterHeader => !isRef(param) && param.in === 'header';\nexport const isCookieParam =\n  (param: OpenapiParameter): param is OpenapiParameterCookie => !isRef(param) && param.in === 'cookie';\n","import {parse} from 'path';\nimport {AutomatonContext, OpenapiReference} from '../types';\nimport {fetch} from './fetch';\nimport {isRef} from './openapi';\nimport {isUrl} from './url';\n\nexport const referenceTitle = (schema: OpenapiReference): string => {\n  const [url = '', path = ''] = schema.$ref.split('#');\n  const paths = path.split('/').slice(1);\n  if (paths.length) {\n    return paths[paths.length - 1]!;\n  } else if (isUrl(url)) {\n    return parse(url).name;\n  }\n  throw new Error(`Invalid ref format: ${schema.$ref}\\n  Can not extract name.`);\n};\n\ntype ReferenceSchema<T = unknown> = (T | OpenapiReference) | (T & OpenapiReference);\nexport const referenceSchema =\n  async <T = unknown>(schema: ReferenceSchema<T>, {openapi, settings: {openapiPath}}: AutomatonContext): Promise<T> => {\n    if (!isRef(schema)) return schema;\n    const [url, path] = schema.$ref.split('#');\n    const file = url ? await fetch<T>(url, openapiPath) : openapi;\n    if (!path) {\n      if (!file) {\n        throw new Error(`Invalid ref path ${schema.$ref}`);\n      }\n      return file as T;\n    }\n    const paths = path?.split('/').slice(1);\n    const extractSchema = paths?.reduce((pre: any, cur) => pre?.[cur], file) as T | undefined;\n    if (!extractSchema) {\n      throw new Error(`Invalid ref path ${schema.$ref}`);\n    }\n    return extractSchema;\n  };\n","import {\n  OpenapiSchema,\n  OpenapiSchemaAllOf,\n  OpenapiSchemaArray,\n  OpenapiSchemaBoolean,\n  OpenapiSchemaInteger,\n  OpenapiSchemaNumber,\n  OpenapiSchemaObject,\n  OpenapiSchemaOneOf,\n  OpenapiSchemaReference,\n  OpenapiSchemaString,\n} from '../types';\n\nexport const isSchemaString =\n  (type: OpenapiSchema): type is OpenapiSchemaString => (type as OpenapiSchemaString).type === 'string';\nexport const isSchemaNumber =\n  (type: OpenapiSchema): type is OpenapiSchemaNumber => (type as OpenapiSchemaNumber).type === 'number';\nexport const isSchemaInteger =\n  (type: OpenapiSchema): type is OpenapiSchemaInteger => (type as OpenapiSchemaInteger).type === 'integer';\nexport const isSchemaBoolean =\n  (type: OpenapiSchema): type is OpenapiSchemaBoolean => (type as OpenapiSchemaBoolean).type === 'boolean';\nexport const isSchemaObject =\n  (type: OpenapiSchema): type is OpenapiSchemaObject =>\n    (type as OpenapiSchemaObject).type === 'object' || Object.hasOwn(type, 'properties');\nexport const isSchemaArray =\n  (type: OpenapiSchema): type is OpenapiSchemaArray =>\n    (type as OpenapiSchemaArray).type === 'array' || Object.hasOwn(type, 'items');\nexport const isSchemaAllOf =\n  (type: OpenapiSchema): type is OpenapiSchemaAllOf => Object.hasOwn(type, 'allOf');\nexport const isSchemaOneOf =\n  (type: OpenapiSchema): type is OpenapiSchemaOneOf => Object.hasOwn(type, 'oneOf');\nexport const isSchemaRef =\n  (type: OpenapiSchema): type is OpenapiSchemaReference => Object.hasOwn(type, '$ref');\n"],"mappings":"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","names":["parse","parse"]}

package/package.json

@@ -1,53 +1,58 @@
 {
   "name": "@automatons/tools",
-  "version": "1.0.218",
-  "repository": "git@github.com:openapi-automatons/tools.git",
+  "version": "2.0.1",
+  "repository": "https://github.com/openapi-automatons/tools.git",
   "author": "tanmen <yt.prog@gmail.com>",
   "license": "MIT",
+  "packageManager": "yarn@1.22.22",
+  "type": "module",
   "keywords": [
     "openapi",
     "openapi-automatons",
     "automatons"
   ],
   "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
   "scripts": {
-    "prebuild": "depcheck && node scripts/prebuild.js",
-    "build": "tsc && cp package.json README.md LICENSE dist",
-    "lint": "eslint src --ext .ts,.tsx",
-    "test": "jest",
-    "postinstall": "husky install && typesync && yarn check --integrity || yarn install --ignore-scripts && yarn-deduplicate",
-    "postversion": "cp package.json ../package.json"
+    "prebuild": "depcheck",
+    "build": "tsup && cp package.json README.md LICENSE dist",
+    "lint": "eslint src",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepare": "husky"
   },
   "dependencies": {
-    "fs-extra": "^10.1.0",
-    "got": "^11.8.5",
     "js-yaml": "^4.1.0"
   },
   "devDependencies": {
-    "@commitlint/cli": "^17.4.1",
-    "@commitlint/config-conventional": "^17.4.0",
-    "@semantic-release/changelog": "^6.0.2",
+    "@commitlint/cli": "^21.0.2",
+    "@commitlint/config-conventional": "^21.0.2",
+    "@eslint/js": "^9.39.0",
+    "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
-    "@semantic-release/npm": "^9.0.1",
-    "@types/eslint": "^8.4.10",
-    "@types/fs-extra": "^9.0.13",
-    "@types/jest": "^27.5.0",
-    "@types/js-yaml": "^4.0.5",
-    "@types/node": "^18.11.18",
-    "@types/semantic-release": "^17.2.4",
-    "@typescript-eslint/eslint-plugin": "^5.48.0",
-    "@typescript-eslint/parser": "^5.48.0",
-    "depcheck": "^1.4.3",
-    "eslint": "^8.28.0",
-    "eslint-config-google": "^0.14.0",
-    "husky": "^8.0.3",
-    "jest": "^26.0.1",
-    "lint-staged": "^13.1.0",
-    "semantic-release": "^19.0.5",
-    "ts-jest": "^26.0.0",
-    "typescript": "^4.7.4",
-    "typesync": "^0.9.2",
-    "yarn-deduplicate": "^6.0.1"
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^24.0.0",
+    "@vitest/coverage-v8": "^3.2.0",
+    "depcheck": "^1.4.7",
+    "eslint": "^9.39.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.0.7",
+    "semantic-release": "^25.0.3",
+    "tsup": "^8.5.0",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.46.0",
+    "vitest": "^3.2.0"
   },
   "publishConfig": {
     "access": "public"

package/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AAExB,oBAAY,OAAO,GAAG;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,gBAAgB,EAAE,CAAA;CAC/B,CAAA;AAED,oBAAY,gBAAgB,GAAG;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAA"}

package/types/automaton.d.ts

@@ -1,12 +0,0 @@
-import { Openapi } from './openapi';
-export declare type AutomatonContext = {
-    openapi: Openapi;
-    settings: AutomatonSettings;
-};
-export declare type AutomatonSettings = {
-    outDir: string;
-    path: string;
-    openapiPath: string;
-};
-export declare type Automaton = (openapi: Openapi, settings: AutomatonSettings, options: object | undefined) => unknown;
-//# sourceMappingURL=automaton.d.ts.map

package/types/automaton.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"automaton.d.ts","sourceRoot":"","sources":["../../src/types/automaton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAC;AAElC,oBAAY,gBAAgB,GAAG;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,iBAAiB,CAAC;CAC7B,CAAA;AAED,oBAAY,iBAAiB,GAAG;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB,CAAA;AAED,oBAAY,SAAS,GAAG,CAAC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,MAAM,GAAG,SAAS,KAAK,OAAO,CAAA"}

package/types/automaton.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=automaton.js.map

package/types/automaton.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"automaton.js","sourceRoot":"","sources":["../../src/types/automaton.ts"],"names":[],"mappings":""}

package/types/http.d.ts

@@ -1,2 +0,0 @@
-export declare type Method = 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace';
-//# sourceMappingURL=http.d.ts.map

package/types/http.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/types/http.ts"],"names":[],"mappings":"AAAA,oBAAY,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC"}

package/types/http.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=http.js.map

package/types/http.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"http.js","sourceRoot":"","sources":["../../src/types/http.ts"],"names":[],"mappings":""}

package/types/index.d.ts

@@ -1,4 +0,0 @@
-export * from './http';
-export * from './openapi';
-export * from './automaton';
-//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC"}