@goast/core 0.4.0-beta4 → 0.4.1

package/script/src/transform/helpers.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdGenerator = void 0;
+exports.determineSchemaKind = determineSchemaKind;
+exports.determineSchemaName = determineSchemaName;
+exports.determineSchemaAccessibility = determineSchemaAccessibility;
+exports.updateSchemaAccessibility = updateSchemaAccessibility;
+exports.getCustomFields = getCustomFields;
+exports.determineEndpointName = determineEndpointName;
+exports.transformAdditionalProperties = transformAdditionalProperties;
+exports.transformSchemaProperties = transformSchemaProperties;
+exports.getOpenApiObjectIdentifier = getOpenApiObjectIdentifier;
+const node_path_1 = require("node:path");
+const internal_utils_js_1 = require("../internal-utils.js");
+const common_utils_js_1 = require("../utils/common.utils.js");
+const object_utils_js_1 = require("../utils/object.utils.js");
+function determineSchemaKind(ctx, schema) {
+    if (schema.oneOf) {
+        return 'oneOf';
+    }
+    else if (schema.type !== 'object' && (schema.allOf || schema.anyOf)) {
+        const hasProperties = (schema.properties && Object.keys(schema.properties).length > 0) ||
+            schema.additionalProperties;
+        return hasProperties ? 'object' : 'combined';
+    }
+    else if (Array.isArray(schema.type)) {
+        return 'multi-type';
+    }
+    else if (schema.type === 'object' ||
+        schema.type === 'string' ||
+        schema.type === 'boolean' ||
+        schema.type === 'null' ||
+        schema.type === 'number' ||
+        schema.type === 'integer' ||
+        schema.type === 'array') {
+        return schema.type;
+    }
+    const treadAsObject = ctx.config.unknownTypeBehavior === 'always-object' ||
+        (ctx.config.unknownTypeBehavior === 'object-if-properties' &&
+            schema.properties &&
+            Object.keys(schema.properties).length > 0);
+    return treadAsObject ? 'object' : 'unknown';
+}
+function determineSchemaName(schema, id) {
+    var _a, _b, _c, _d, _e, _f;
+    if (schema.title)
+        return { name: schema.title, isGenerated: false };
+    if (!schema.$src) {
+        console.log('woot?');
+    }
+    if (schema.$src.path === '/')
+        return { name: (0, node_path_1.parse)(schema.$src.file).name, isGenerated: true };
+    const schemaNameMatch = schema.$src.path.match(/(?<=\/components\/schemas\/|\/definitions\/)[^/]+$/i);
+    if (schemaNameMatch) {
+        return { name: schemaNameMatch[0], isGenerated: false };
+    }
+    const responseMatch = schema.$src.path.match(/\/paths\/(?<path>.+)\/(?<method>.+)\/responses\/(?<status>\d+)\//);
+    if (responseMatch && responseMatch.groups) {
+        const { path, method, status } = responseMatch.groups;
+        const operation = (_c = (_b = (_a = schema.$src.document.paths) === null || _a === void 0 ? void 0 : _a[path]) === null || _b === void 0 ? void 0 : _b[method]) !== null && _c !== void 0 ? _c : {};
+        return {
+            name: `${determineEndpointName({ method, path: `/${path}`, operation })}_${status}_Response`,
+            isGenerated: true,
+        };
+    }
+    const responseCompMatch = schema.$src.path.match(/\/components\/responses\/([^/]+)\/content\/.+\/schema/);
+    if (responseCompMatch) {
+        return {
+            name: responseCompMatch[1].toLowerCase().endsWith('response')
+                ? responseCompMatch[1]
+                : responseCompMatch[1] + 'Response',
+            isGenerated: true,
+        };
+    }
+    const requestBodyMatch = schema.$src.path.match(/\/paths\/(?<path>.+)\/(?<method>.+)\/requestBody\//);
+    if (requestBodyMatch && requestBodyMatch.groups) {
+        const { path, method } = requestBodyMatch.groups;
+        const operation = (_f = (_e = (_d = schema.$src.document.paths) === null || _d === void 0 ? void 0 : _d[path]) === null || _e === void 0 ? void 0 : _e[method]) !== null && _f !== void 0 ? _f : {};
+        return { name: `${determineEndpointName({ method, path: `/${path}`, operation })}_Request`, isGenerated: true };
+    }
+    const parentSchemaMatch = schema.$src.path.match(/(.*)\/properties\/([^/]*)$/);
+    if (parentSchemaMatch) {
+        const parentSchema = (0, object_utils_js_1.getDeepProperty)(schema.$src.document, parentSchemaMatch[1].split('/').filter(Boolean));
+        const parentSchemaName = determineSchemaName({
+            title: typeof parentSchema === 'object' && parentSchema !== null && 'title' in parentSchema
+                ? String(parentSchema.title)
+                : undefined,
+            $src: {
+                file: schema.$src.file,
+                path: parentSchemaMatch[1],
+                document: schema.$src.document,
+                originalComponent: parentSchema,
+            },
+        }, id);
+        if (!parentSchemaName.isGenerated) {
+            return { name: `${parentSchemaName.name}_${parentSchemaMatch[2]}`, isGenerated: true };
+        }
+    }
+    return { name: id, isGenerated: true };
+}
+function determineSchemaAccessibility(schema) {
+    if (schema.readOnly === true) {
+        return schema.writeOnly === true ? 'none' : 'readOnly';
+    }
+    else {
+        return schema.writeOnly === true ? 'writeOnly' : 'all';
+    }
+}
+function updateSchemaAccessibility(accessibility, schema) {
+    if (accessibility === 'none')
+        return 'none';
+    if (accessibility === 'readOnly')
+        return schema.writeOnly === true ? 'none' : 'readOnly';
+    if (accessibility === 'writeOnly')
+        return schema.readOnly === true ? 'none' : 'writeOnly';
+    return determineSchemaAccessibility(schema);
+}
+function getCustomFields(schema) {
+    const result = {};
+    for (const key in schema) {
+        if (key.startsWith('x-')) {
+            const name = key.substring(2);
+            result[name] = schema[key];
+        }
+    }
+    return result;
+}
+function determineEndpointName(endpointInfo) {
+    if (endpointInfo.operation.operationId)
+        return endpointInfo.operation.operationId;
+    return endpointInfo.method + endpointInfo.path.replace(/\{([^}]+)\}/g, ':$1').replace(/\//g, '_');
+}
+function transformAdditionalProperties(context, schema, transformSchema) {
+    if ((0, common_utils_js_1.isNullish)(schema.additionalProperties))
+        return undefined;
+    if (typeof schema.additionalProperties === 'boolean')
+        return schema.additionalProperties;
+    return transformSchema(context, schema.additionalProperties);
+}
+function transformSchemaProperties(context, schema, transformSchema) {
+    const result = new Map();
+    if (!schema.properties)
+        return result;
+    for (const name of Object.keys(schema.properties)) {
+        if (!(0, internal_utils_js_1.isOpenApiObjectProperty)(name))
+            continue;
+        result.set(name, {
+            name,
+            schema: transformSchema(context, schema.properties[name]),
+        });
+    }
+    return result;
+}
+class IdGenerator {
+    constructor() {
+        Object.defineProperty(this, "_idMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    generateId(name) {
+        var _a;
+        const id = (_a = this._idMap.get(name)) !== null && _a !== void 0 ? _a : 1;
+        this._idMap.set(name, id + 1);
+        return `${name}-${id}`;
+    }
+}
+exports.IdGenerator = IdGenerator;
+function getOpenApiObjectIdentifier(obj) {
+    return obj.$src.file + '#' + obj.$src.path;
+}

package/script/src/transform/helpers.test.d.ts

@@ -0,0 +1,2 @@
+import "../../_dnt.test_polyfills.js";
+//# sourceMappingURL=helpers.test.d.ts.map

package/script/src/transform/helpers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.test.d.ts","sourceRoot":"","sources":["../../../src/src/transform/helpers.test.ts"],"names":[],"mappings":"AAAA,OAAO,8BAA8B,CAAC"}

package/script/src/transform/helpers.test.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("../../_dnt.test_polyfills.js");
+const mod_js_1 = require("../../deps/jsr.io/@std/expect/1.0.12/mod.js");
+const bdd_js_1 = require("../../deps/jsr.io/@std/testing/1.0.9/bdd.js");
+const helpers_js_1 = require("./helpers.js");
+(0, bdd_js_1.describe)('determineSchemaKind', () => {
+    const ctx = { config: { unknownTypeBehavior: 'keep-unknown' } };
+    (0, bdd_js_1.test)('returns "oneOf" if schema has "oneOf" property', () => {
+        const schema = { oneOf: [{}] };
+        (0, mod_js_1.expect)((0, helpers_js_1.determineSchemaKind)(ctx, schema)).toBe('oneOf');
+    });
+    (0, bdd_js_1.test)('returns "combined" if schema has "allOf" or "anyOf" property', () => {
+        const schema = { allOf: [{}], anyOf: [{}] };
+        (0, mod_js_1.expect)((0, helpers_js_1.determineSchemaKind)(ctx, schema)).toBe('combined');
+    });
+    (0, bdd_js_1.test)('returns "multi-type" if schema has "type" property as an array', () => {
+        const schema = { type: ['string', 'number'] };
+        (0, mod_js_1.expect)((0, helpers_js_1.determineSchemaKind)(ctx, schema)).toBe('multi-type');
+    });
+    (0, bdd_js_1.test)('returns the value of "type" property if it is a string', () => {
+        const schema = { type: 'string' };
+        (0, mod_js_1.expect)((0, helpers_js_1.determineSchemaKind)(ctx, schema)).toBe('string');
+    });
+    (0, bdd_js_1.test)('returns "unknown" if schema has no recognizable properties', () => {
+        const schema = {};
+        (0, mod_js_1.expect)((0, helpers_js_1.determineSchemaKind)(ctx, schema)).toBe('unknown');
+    });
+});
+(0, bdd_js_1.describe)('determineSchemaName', () => {
+    (0, bdd_js_1.test)('returns the schema title if it exists', () => {
+        const schema = {
+            title: 'TestSchema',
+            $src: { file: 'my-api.yml', path: '/test/schema', document: {}, originalComponent: {} },
+        };
+        (0, mod_js_1.expect)((0, helpers_js_1.determineSchemaName)(schema, 'TestId')).toEqual({
+            name: 'TestSchema',
+            isGenerated: false,
+        });
+    });
+    (0, bdd_js_1.test)("returns the json schema file name if the schema title doesn't exist", () => {
+        const schema = {
+            $src: { path: '/', file: 'test.json', document: {}, originalComponent: {} },
+        };
+        (0, mod_js_1.expect)((0, helpers_js_1.determineSchemaName)(schema, 'TestId')).toEqual({
+            name: 'test',
+            isGenerated: true,
+        });
+    });
+    (0, bdd_js_1.test)('returns the schema name extracted from $src.path if it starts with "/components/schemas/"', () => {
+        const schema = {
+            $src: {
+                file: 'my-api.yml',
+                path: '/components/schemas/TestSchema',
+                document: {},
+                originalComponent: {},
+            },
+        };
+        (0, mod_js_1.expect)((0, helpers_js_1.determineSchemaName)(schema, 'TestId')).toEqual({
+            name: 'TestSchema',
+            isGenerated: false,
+        });
+    });
+    (0, bdd_js_1.test)('returns the schema name extracted from $src.path if it starts with "/definitions/"', () => {
+        const schema = {
+            $src: {
+                file: 'my-api.yml',
+                path: '/definitions/TestSchema',
+                document: {},
+                originalComponent: {},
+            },
+        };
+        (0, mod_js_1.expect)((0, helpers_js_1.determineSchemaName)(schema, 'TestId')).toEqual({
+            name: 'TestSchema',
+            isGenerated: false,
+        });
+    });
+    (0, bdd_js_1.test)('returns a generated name based on the $src.path for response schemas', () => {
+        const schema = {
+            $src: {
+                file: 'my-api.yml',
+                path: '/paths/users/{userId}/email-verification/{token}/get/responses/200/',
+                document: {},
+                originalComponent: {},
+            },
+        };
+        (0, mod_js_1.expect)((0, helpers_js_1.determineSchemaName)(schema, 'TestId')).toEqual({
+            name: 'get_users_:userId_email-verification_:token_200_Response',
+            isGenerated: true,
+        });
+    });
+    (0, bdd_js_1.test)('returns the provided id if no other name can be determined', () => {
+        const schema = {
+            $src: { file: 'my-api.yml', path: '/test/schema', document: {}, originalComponent: {} },
+        };
+        (0, mod_js_1.expect)((0, helpers_js_1.determineSchemaName)(schema, 'TestId')).toEqual({ name: 'TestId', isGenerated: true });
+    });
+});
+(0, bdd_js_1.describe)('determineSchemaAccessibility', () => {
+    (0, bdd_js_1.test)('returns "readOnly" if "readOnly" property is true and "writeOnly" property is false or undefined', () => {
+        const schema = { readOnly: true };
+        (0, mod_js_1.expect)((0, helpers_js_1.determineSchemaAccessibility)(schema)).toBe('readOnly');
+    });
+    (0, bdd_js_1.test)('returns "writeOnly" if "writeOnly" property is true and "readOnly" property is false or undefined', () => {
+        const schema = { writeOnly: true };
+        (0, mod_js_1.expect)((0, helpers_js_1.determineSchemaAccessibility)(schema)).toBe('writeOnly');
+    });
+    (0, bdd_js_1.test)('returns "none" if both "readOnly" and "writeOnly" properties are true', () => {
+        const schema = { readOnly: true, writeOnly: true };
+        (0, mod_js_1.expect)((0, helpers_js_1.determineSchemaAccessibility)(schema)).toBe('none');
+    });
+    (0, bdd_js_1.test)('returns "all" if neither "readOnly" nor "writeOnly" properties are true', () => {
+        const schema = {};
+        (0, mod_js_1.expect)((0, helpers_js_1.determineSchemaAccessibility)(schema)).toBe('all');
+    });
+});
+(0, bdd_js_1.describe)('getCustomFields', () => {
+    (0, bdd_js_1.test)('returns an empty object if no custom fields are present', () => {
+        const schema = { type: 'string' };
+        (0, mod_js_1.expect)((0, helpers_js_1.getCustomFields)(schema)).toEqual({});
+    });
+    (0, bdd_js_1.test)('returns an object containing all custom fields starting with "x-"', () => {
+        const schema = {
+            type: 'string',
+            'x-custom-field-1': 'value1',
+            'x-custom-field-2': 'value2',
+        };
+        (0, mod_js_1.expect)((0, helpers_js_1.getCustomFields)(schema)).toEqual({
+            'custom-field-1': 'value1',
+            'custom-field-2': 'value2',
+        });
+    });
+    (0, bdd_js_1.test)('returns an object containing only custom fields starting with "x-"', () => {
+        const schema = {
+            type: 'string',
+            'x-custom-field-1': 'value1',
+            'not-a-custom-field': 'value2',
+        };
+        (0, mod_js_1.expect)((0, helpers_js_1.getCustomFields)(schema)).toEqual({ 'custom-field-1': 'value1' });
+    });
+    (0, bdd_js_1.test)('returns an object with the same values as the original custom fields', () => {
+        const schema = {
+            type: 'string',
+            'x-custom-field-1': { key1: 'value1' },
+            'x-custom-field-2': ['value2'],
+        };
+        (0, mod_js_1.expect)((0, helpers_js_1.getCustomFields)(schema)).toEqual({
+            'custom-field-1': { key1: 'value1' },
+            'custom-field-2': ['value2'],
+        });
+    });
+});
+(0, bdd_js_1.describe)('determineEndpointName', () => {
+    (0, bdd_js_1.test)('returns the operationId if it exists', () => {
+        const endpointInfo = {
+            method: 'get',
+            path: '/users',
+            operation: { operationId: 'getUserList' },
+        };
+        (0, mod_js_1.expect)((0, helpers_js_1.determineEndpointName)(endpointInfo)).toBe('getUserList');
+    });
+    (0, bdd_js_1.test)('returns a generated name based on the method and path if operationId is not present', () => {
+        const endpointInfo = { method: 'post', path: '/users/{userId}/comments', operation: {} };
+        (0, mod_js_1.expect)((0, helpers_js_1.determineEndpointName)(endpointInfo)).toBe('post_users_:userId_comments');
+    });
+    (0, bdd_js_1.test)('replaces path parameters with their names in the generated name', () => {
+        const endpointInfo = {
+            method: 'get',
+            path: '/users/{userId}/comments/{commentId}',
+            operation: {},
+        };
+        (0, mod_js_1.expect)((0, helpers_js_1.determineEndpointName)(endpointInfo)).toBe('get_users_:userId_comments_:commentId');
+    });
+    (0, bdd_js_1.test)('replaces slashes in the path with underscores in the generated name', () => {
+        const endpointInfo = { method: 'put', path: '/users/{userId}/profile-picture', operation: {} };
+        (0, mod_js_1.expect)((0, helpers_js_1.determineEndpointName)(endpointInfo)).toBe('put_users_:userId_profile-picture');
+    });
+});
+(0, bdd_js_1.describe)('transformAdditionalProperties', () => {
+    const context = {};
+    (0, bdd_js_1.test)('returns undefined if additionalProperties is undefined or null', () => {
+        const schema1 = { additionalProperties: undefined };
+        const schema2 = { additionalProperties: null };
+        (0, mod_js_1.expect)((0, helpers_js_1.transformAdditionalProperties)(context, schema1, () => ({}))).toBeUndefined();
+        (0, mod_js_1.expect)((0, helpers_js_1.transformAdditionalProperties)(context, schema2, () => ({}))).toBeUndefined();
+    });
+    (0, bdd_js_1.test)('returns a boolean value if additionalProperties is a boolean value', () => {
+        const schema1 = { additionalProperties: true };
+        const schema2 = { additionalProperties: false };
+        (0, mod_js_1.expect)((0, helpers_js_1.transformAdditionalProperties)(context, schema1, () => ({}))).toBe(true);
+        (0, mod_js_1.expect)((0, helpers_js_1.transformAdditionalProperties)(context, schema2, () => ({}))).toBe(false);
+    });
+    (0, bdd_js_1.test)('calls transformSchema with the additionalProperties schema if it exists', () => {
+        const schema = { additionalProperties: { type: 'string' } };
+        const transformSchema = (0, mod_js_1.fn)(() => ({}));
+        (0, helpers_js_1.transformAdditionalProperties)(context, schema, transformSchema);
+        (0, mod_js_1.expect)(transformSchema).toHaveBeenCalledWith(context, schema.additionalProperties);
+    });
+    (0, bdd_js_1.test)('returns the result of calling transformSchema with the additionalProperties schema if it exists', () => {
+        const schema = { additionalProperties: { type: 'string' } };
+        const transformedSchema = { type: 'string' };
+        const transformSchema = (0, mod_js_1.fn)(() => transformedSchema);
+        (0, mod_js_1.expect)((0, helpers_js_1.transformAdditionalProperties)(context, schema, transformSchema)).toBe(transformedSchema);
+    });
+});
+(0, bdd_js_1.describe)('transformSchemaProperties', () => {
+    const context = {};
+    (0, bdd_js_1.test)('returns an empty array if properties is undefined', () => {
+        const schema = {};
+        const transformSchema = (0, mod_js_1.fn)(() => ({}));
+        (0, mod_js_1.expect)((0, helpers_js_1.transformSchemaProperties)(context, schema, transformSchema).size).toEqual(0);
+    });
+    (0, bdd_js_1.test)('calls transformSchema with each property schema and builds an array of ApiSchemaProperties', () => {
+        const schema = {
+            properties: {
+                prop1: { type: 'string' },
+                prop2: { type: 'integer' },
+            },
+            required: ['prop1'],
+        };
+        const transformedSchema1 = { type: 'string' };
+        const transformedSchema2 = { type: 'integer' };
+        // deno-lint-ignore no-explicit-any
+        const transformSchema = (0, mod_js_1.fn)((_, subSchema) => subSchema.type === 'string' ? transformedSchema1 : transformedSchema2);
+        const result = (0, helpers_js_1.transformSchemaProperties)(context, schema, transformSchema);
+        (0, mod_js_1.expect)(Array.from(result.entries())).toEqual([
+            ['prop1', { name: 'prop1', schema: transformedSchema1 }],
+            ['prop2', { name: 'prop2', schema: transformedSchema2 }],
+        ]);
+        (0, mod_js_1.expect)(transformSchema).toHaveBeenCalledTimes(2);
+        (0, mod_js_1.expect)(transformSchema).toHaveBeenCalledWith(context, schema.properties.prop1);
+        (0, mod_js_1.expect)(transformSchema).toHaveBeenCalledWith(context, schema.properties.prop2);
+    });
+    (0, bdd_js_1.test)('ignores properties with the name "$src"', () => {
+        const schema = { properties: { prop1: { type: 'string' }, $src: { path: '/test/schema' } } };
+        const transformedSchema1 = { type: 'string' };
+        const transformSchema = (0, mod_js_1.fn)(() => transformedSchema1);
+        const result = (0, helpers_js_1.transformSchemaProperties)(context, schema, transformSchema);
+        (0, mod_js_1.expect)(Array.from(result.entries())).toEqual([['prop1', { name: 'prop1', schema: transformedSchema1 }]]);
+        (0, mod_js_1.expect)(transformSchema).toHaveBeenCalledTimes(1);
+        (0, mod_js_1.expect)(transformSchema).toHaveBeenCalledWith(context, schema.properties.prop1);
+    });
+});
+(0, bdd_js_1.describe)('IdGenerator', () => {
+    (0, bdd_js_1.test)('generates unique ids based on the provided name', () => {
+        const idGenerator = new helpers_js_1.IdGenerator();
+        const id1 = idGenerator.generateId('test');
+        const id2 = idGenerator.generateId('test');
+        (0, mod_js_1.expect)(id1).not.toBe(id2);
+    });
+    (0, bdd_js_1.test)('generates ids with the format "{name}-{n}"', () => {
+        const idGenerator = new helpers_js_1.IdGenerator();
+        const id1 = idGenerator.generateId('test');
+        (0, mod_js_1.expect)(id1).toMatch(/^test-\d+$/);
+    });
+    (0, bdd_js_1.test)('increments the id number for each new id generated with the same name', () => {
+        const idGenerator = new helpers_js_1.IdGenerator();
+        const id1 = idGenerator.generateId('test');
+        const id2 = idGenerator.generateId('test');
+        const id3 = idGenerator.generateId('test2');
+        const id4 = idGenerator.generateId('test');
+        (0, mod_js_1.expect)(id1).toBe('test-1');
+        (0, mod_js_1.expect)(id2).toBe('test-2');
+        (0, mod_js_1.expect)(id3).toBe('test2-1');
+        (0, mod_js_1.expect)(id4).toBe('test-3');
+    });
+});

package/script/src/transform/transform-document.d.ts

@@ -0,0 +1,5 @@
+import type { OpenApiDocument } from '../parse/openapi-types.js';
+import type { Deref } from '../parse/types.js';
+import type { OpenApiTransformerContext } from './types.js';
+export declare function transformDocument(context: OpenApiTransformerContext, document: Deref<OpenApiDocument>): void;
+//# sourceMappingURL=transform-document.d.ts.map

package/script/src/transform/transform-document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-document.d.ts","sourceRoot":"","sources":["../../../src/src/transform/transform-document.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAc,MAAM,2BAA2B,CAAC;AAC7E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAG/C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAE5D,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,yBAAyB,EAAE,QAAQ,EAAE,KAAK,CAAC,eAAe,CAAC,QAIrG"}

package/script/src/transform/transform-endpoint.d.ts

@@ -0,0 +1,5 @@
+import type { OpenApiCollectorEndpointInfo } from '../collect/types.js';
+import type { ApiEndpoint } from './api-types.js';
+import type { OpenApiTransformerContext } from './types.js';
+export declare function transformEndpoint(context: OpenApiTransformerContext, endpointInfo: OpenApiCollectorEndpointInfo): ApiEndpoint;
+//# sourceMappingURL=transform-endpoint.d.ts.map

package/script/src/transform/transform-endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-endpoint.d.ts","sourceRoot":"","sources":["../../../src/src/transform/transform-endpoint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAYxE,OAAO,KAAK,EAEV,WAAW,EAOZ,MAAM,gBAAgB,CAAC;AAGxB,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAE5D,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,yBAAyB,EAAE,YAAY,EAAE,4BAA4B,eAiD/G"}