swaggular 0.2.2 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swaggular",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {

package/dist/app/get-parse-args.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getParseArgs = getParseArgs;
-function getParseArgs(argv) {
-    const args = {};
-    const positional = [];
-    for (let i = 0; i < argv.length; i++) {
-        const arg = argv[i];
-        if (arg.startsWith("--") && arg.includes("=")) {
-            const [k, v] = arg.slice(2).split("=");
-            args[k] = v;
-            continue;
-        }
-        if (arg.startsWith("--")) {
-            const k = arg.slice(2);
-            const next = argv[i + 1];
-            if (!next || next.startsWith("-")) {
-                args[k] = true;
-            }
-            else {
-                args[k] = next;
-                i++;
-            }
-            continue;
-        }
-        if (arg.startsWith("-") && arg.length > 2) {
-            arg
-                .slice(1)
-                .split("")
-                .forEach((k) => (args[k] = true));
-            continue;
-        }
-        if (arg.startsWith("-")) {
-            const k = arg.slice(1);
-            const next = argv[i + 1];
-            if (!next || next.startsWith("-")) {
-                args[k] = true;
-            }
-            else {
-                args[k] = next;
-                i++;
-            }
-            continue;
-        }
-        positional.push(arg);
-    }
-    return { args, positional };
-}

package/dist/app/parse-variables.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toVariables = toVariables;
-function toVariables(parsed) {
-    const variables = {};
-    if (parsed.args.mode) {
-        variables.groupingMode = parsed.args.mode;
-    }
-    if (parsed.args.segmentsToIgnore) {
-        if (typeof parsed.args.segmentsToIgnore === "string") {
-            variables.segmentsToIgnore = parsed.args.segmentsToIgnore.split(",");
-        }
-    }
-    if (parsed.args.ignoreVariables) {
-        variables.ignoreVariables =
-            parsed.args.ignoreVariables === "true" ||
-                parsed.args.ignoreVariables === true;
-    }
-    return {
-        groupingMode: variables.groupingMode || "path",
-        segmentsToIgnore: variables.segmentsToIgnore || ["api"],
-        ignoreVariables: variables.ignoreVariables || true,
-    };
-}

package/dist/builders/build-comments.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildComments = buildComments;
-function buildComments(param) {
-    const comments = [];
-    if (param.format !== undefined) {
-        comments.push(`format: ${param.format}`);
-    }
-    if (param.minLength !== undefined) {
-        comments.push(`minLength: ${param.minLength}`);
-    }
-    if (param.maxLength !== undefined) {
-        comments.push(`maxLength: ${param.maxLength}`);
-    }
-    if (param.minimum !== undefined) {
-        comments.push(`minimum: ${param.minimum}`);
-    }
-    if (param.maximum !== undefined) {
-        comments.push(`maximum: ${param.maximum}`);
-    }
-    if (comments.length > 0) {
-        return `  /**\n   * ${comments.join("\n   * ")}\n   */`;
-    }
-    return "";
-}

package/dist/examples/services/get.example.js

@@ -1 +0,0 @@
-"use strict";

package/dist/generators/generate-comments.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateInterfaceComments = generateInterfaceComments;
-exports.generateServiceComments = generateServiceComments;
-function generateInterfaceComments(param) {
-    const comments = [];
-    if (param.format !== undefined) {
-        comments.push(`format: ${param.format}`);
-    }
-    if (param.minLength !== undefined) {
-        comments.push(`minLength: ${param.minLength}`);
-    }
-    if (param.maxLength !== undefined) {
-        comments.push(`maxLength: ${param.maxLength}`);
-    }
-    if (param.minimum !== undefined) {
-        comments.push(`minimum: ${param.minimum}`);
-    }
-    if (param.maximum !== undefined) {
-        comments.push(`maximum: ${param.maximum}`);
-    }
-    if (comments.length > 0) {
-        return `  /**\n   * ${comments.join("\n   * ")}\n   */`;
-    }
-    return "";
-}
-function generateServiceComments(summary, responseType, parameters) {
-    const summarySplited = [];
-    for (let i = 0; i < summary.length; i += 100) {
-        summarySplited.push(summary.slice(i, i + 100));
-    }
-    const comments = summarySplited;
-    if (parameters && parameters.length > 0) {
-        comments.push(`${parameters.map((p) => `\t\t @param ${p.name} : ${p.type}`).join("\n")}`);
-    }
-    if (responseType) {
-        comments.push(`\t\t @returns Observable<${responseType}>`);
-    }
-    return `/**\n${comments.map((c) => `\t\t* ${c}\n`).join("")}\n */`;
-}

package/dist/generators/generate-interface.js

@@ -1,219 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parametersToIProperties = parametersToIProperties;
-exports.propertiesToIProperties = propertiesToIProperties;
-exports.generateInterfaces = generateInterfaces;
-exports.generateWithParameters = generateWithParameters;
-exports.computeParametersName = computeParametersName;
-exports.generateComponentsSchemas = generateComponentsSchemas;
-exports.generateInterfacesFiles = generateInterfacesFiles;
-exports.generateContent = generateContent;
-const interface_data_store_1 = require("../stores/interface-data-store");
-const swagger_store_1 = require("../stores/swagger-store");
-const extends_from_types_1 = require("../templates/types/extends-from-types");
-const generic_types_1 = require("../templates/types/generic-types");
-const build_types_1 = require("../utils/build-types");
-const object_utils_1 = require("../utils/object-utils");
-const path_utils_1 = require("../utils/path-utils");
-const string_utils_1 = require("../utils/string-utils");
-const type_guard_1 = require("../utils/type-guard");
-const generate_comments_1 = require("./generate-comments");
-function parametersToIProperties(parameters) {
-    const properties = [];
-    for (const param of parameters) {
-        if ((0, type_guard_1.isReference)(param)) {
-            const ref = param.$ref.split("/").pop();
-            properties.push({
-                name: (0, string_utils_1.lowerFirst)(ref),
-                type: ref,
-                optional: false,
-                comments: "",
-            });
-            continue;
-        }
-        if (param.in !== "query")
-            continue;
-        const tsType = (0, build_types_1.switchTypeJson)(param.schema);
-        properties.push({
-            name: (0, string_utils_1.lowerFirst)(param.name),
-            type: tsType,
-            optional: !param.required,
-            comments: (0, generate_comments_1.generateInterfaceComments)(param.schema),
-        });
-    }
-    return properties;
-}
-function propertiesToIProperties(properties) {
-    const interfaceDataProperties = [];
-    for (const [name, property] of Object.entries(properties)) {
-        if ((0, type_guard_1.isReference)(property)) {
-            const ref = property.$ref.split("/").pop();
-            interfaceDataProperties.push({
-                name,
-                type: ref,
-                optional: false,
-                comments: "",
-            });
-            continue;
-        }
-        interfaceDataProperties.push({
-            name,
-            type: (0, build_types_1.switchTypeJson)(property),
-            optional: property.nullable ?? false,
-            comments: (0, generate_comments_1.generateInterfaceComments)(property),
-        });
-    }
-    return interfaceDataProperties;
-}
-function generateInterfaces() {
-    generateComponentsSchemas();
-    generateWithParameters();
-}
-function generateWithParameters() {
-    const paths = swagger_store_1.swaggerStore.getPaths();
-    const groupedPaths = swagger_store_1.swaggerStore.getPathsGroupedByScope();
-    if (!paths || !groupedPaths)
-        return;
-    const interfacesData = [];
-    for (const groupedPath of Object.values(groupedPaths)) {
-        for (const innerPath of groupedPath.paths) {
-            const pathInfo = paths[innerPath];
-            if (!pathInfo)
-                continue;
-            const methods = (0, object_utils_1.removeFalsyValues)({
-                get: pathInfo.get,
-                post: pathInfo.post,
-                put: pathInfo.put,
-                delete: pathInfo.delete,
-                patch: pathInfo.patch,
-            });
-            for (const [httpMethod, pathData] of Object.entries(methods)) {
-                if (!pathData?.parameters)
-                    continue;
-                const parameters = pathData.parameters;
-                const properties = parametersToIProperties(parameters);
-                if (properties.length === 0)
-                    continue;
-                const interfaceName = computeParametersName(httpMethod, innerPath, groupedPath);
-                const interData = {
-                    name: interfaceName,
-                    type: "interface",
-                    imports: properties
-                        .filter((p) => !(0, type_guard_1.isNativeType)(p.type))
-                        .map((p) => p.type),
-                    properties,
-                };
-                const generic = (0, generic_types_1.isGenericType)(interData);
-                if (generic)
-                    continue;
-                const interDataWithExtendsFrom = (0, extends_from_types_1.computeExtendsFromType)(interData);
-                interfacesData.push(interDataWithExtendsFrom);
-            }
-        }
-    }
-    interface_data_store_1.interfaceDataStore.addInterfaces(interfacesData);
-}
-function computeParametersName(method, innerPath, groupedPath) {
-    const dict = {
-        get: "",
-        post: "Create",
-        put: "Update",
-        delete: "Delete",
-        patch: "Patch",
-    };
-    const name = dict[method];
-    const extra = (0, string_utils_1.kebabToPascalCase)((0, path_utils_1.removeVariablesFromPath)((0, path_utils_1.getExtraSegments)(innerPath, (0, path_utils_1.createBaseUrl)(groupedPath.baseSegments)).join("")));
-    return name + groupedPath.groupName + (0, string_utils_1.upFirst)(extra) + "Params";
-}
-function generateComponentsSchemas() {
-    const schemas = swagger_store_1.swaggerStore.getSchemas();
-    if (!schemas)
-        return;
-    const interfaces = [];
-    for (const [key, value] of Object.entries(schemas)) {
-        if ((0, type_guard_1.isReference)(value))
-            continue;
-        if (!value.properties) {
-            if (value.enum) {
-                const interData = {
-                    name: key,
-                    type: "enum",
-                    imports: [],
-                    properties: value.enum.map((e) => {
-                        return {
-                            name: e,
-                            type: e,
-                            optional: false,
-                            comments: "",
-                        };
-                    }),
-                };
-                interfaces.push(interData);
-            }
-            continue;
-        }
-        const properties = propertiesToIProperties(value.properties);
-        const interData = {
-            name: key,
-            type: "interface",
-            imports: properties
-                .filter((p) => !(0, type_guard_1.isNativeType)(p.type))
-                .map((p) => p.type),
-            properties,
-        };
-        const generic = (0, generic_types_1.isGenericType)(interData);
-        if (generic) {
-            continue;
-        }
-        const interDataWithExtendsFrom = (0, extends_from_types_1.computeExtendsFromType)(interData);
-        interfaces.push(interDataWithExtendsFrom);
-    }
-    interface_data_store_1.interfaceDataStore.addInterfaces(interfaces);
-}
-function generateInterfacesFiles(locations) {
-    const interfacesData = [
-        ...generic_types_1.genericTypesData,
-        ...extends_from_types_1.extendsFromTypes,
-        ...Array.from(Object.values(interface_data_store_1.interfaceDataStore.generatedInterfaces)),
-    ];
-    const filesContent = [];
-    for (const [key, value] of Object.entries(interfacesData)) {
-        const location = [
-            value.type === "enum" ? "enums" : "dtos",
-            ...(locations?.[key] ?? []),
-        ];
-        const content = generateContent(value, location.length);
-        const extraName = value.type === "enum" ? "enum" : "dto";
-        filesContent.push({
-            location: location,
-            content,
-            extension: "ts",
-            name: (0, string_utils_1.toKebabCase)(value.name) + `.${extraName}`,
-        });
-    }
-    return filesContent;
-}
-generateContent;
-function generateContent(interfaceData, deep = 0) {
-    const imports = [...interfaceData.imports];
-    const importsTemplate = imports.length > 0
-        ? `import { ${imports.join(", ")} } from "${"../".repeat(deep)}models";`
-        : "";
-    if (interfaceData.type === "interface") {
-        const content = `${importsTemplate}\n\nexport interface ${interfaceData.name} ${interfaceData.extendsFrom && interfaceData.extendsFrom.length > 0 ? `extends ${interfaceData.extendsFrom.join(", ")}` : ""} {
-    ${interfaceData.properties
-            .map((p) => `${p.comments}\n\t${(0, string_utils_1.lowerFirst)(p.name)}${p.optional ? "?" : ""}: ${p.type};`)
-            .join("\n")}
-  }`;
-        return content;
-    }
-    if (interfaceData.type === "enum") {
-        const content = `export enum ${interfaceData.name} {
-    ${interfaceData.properties
-            .map((p) => `${p.comments}\n\t${p.name} = '${p.type}',`)
-            .join("\n")}
-  }`;
-        return content;
-    }
-    return "";
-}

package/dist/generators/generate-service.js

@@ -1,302 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateServices = generateServices;
-exports.generateServiceFiles = generateServiceFiles;
-exports.buildMethods = buildMethods;
-exports.buildMethod = buildMethod;
-exports.computeName = computeName;
-const services_store_1 = require("../stores/services-store");
-const swagger_store_1 = require("../stores/swagger-store");
-const angular_template_1 = require("../templates/services/angular-template");
-const build_types_1 = require("../utils/build-types");
-const path_utils_1 = require("../utils/path-utils");
-const string_utils_1 = require("../utils/string-utils");
-const type_guard_1 = require("../utils/type-guard");
-const generate_interface_1 = require("./generate-interface");
-const generate_comments_1 = require("./generate-comments");
-/**
- * Pick the paths grouped by scope and generate services for them.
- * Each group will generate one service data.
- * Each service data will contain the methods for the paths.
- *
- * The name will be the group name concatenated with Service
- *
- * The imports will be the types used in the methods. Including
- * the response type and the parameters types.
- *
- * The base url will be the base url of the group compound by the
- * base segments of the group.
- *
- * Each method will be generated based on a path
- *
- * The method name will be computed based on the path.
- * It has to follow some stantardized rules.
- *
- * The method parameters will be computed based on the path parameters
- * The method path will be computed based on the path, but it will be
- * computed as `${this.baseUrl}/something/else/{id}`
- * The method response type will be computed based on the path response
- * The method parameters will be computed based on the path parameters
- * The method parameter name will be computed based on the path parameter name if
- * the parameters has the property "in" set to "path". If the parameter has the property
- * "in" set to "query", it will be computed as "parameters" and query parameters should be grouped
- * in the same object. Check computeParametersName() method in generate-interface.ts to
- * understand how the name is computed.
- *
- * The method parameter in property will be computed based on the path parameter "in" property
- * The method parameter type will be computed based on the path parameter type property.
- * Check computeParametersName() method in generate-interface.ts to
- * understand how the name is computed.
- * The method parameter required will be computed based on the path parameter required property
- * @returns ServiceData[]
- */
-function generateServices() {
-    const servicesData = [];
-    const groupedPaths = swagger_store_1.swaggerStore.getPathsGroupedByScope();
-    const paths = swagger_store_1.swaggerStore.getPaths();
-    if (!groupedPaths || !paths)
-        return;
-    for (const [key, value] of Object.entries(groupedPaths)) {
-        const methods = buildMethods(value);
-        const importsSet = new Set();
-        methods.forEach((method) => {
-            const allTypes = [
-                method.responseType,
-                ...method.parameters.map((p) => p.type),
-            ];
-            allTypes.forEach((t) => {
-                const identifiers = t.match(/[a-zA-Z_][a-zA-Z0-9_]*/g) || [];
-                identifiers.forEach((id) => {
-                    if (!(0, type_guard_1.isNativeType)(id) && id !== "void") {
-                        importsSet.add(id);
-                    }
-                });
-            });
-        });
-        const serviceData = {
-            name: key + "Service",
-            imports: Array.from(importsSet),
-            baseUrl: value.baseUrl,
-            methods: methods,
-        };
-        servicesData.push(serviceData);
-    }
-    services_store_1.serviceStore.addServices(servicesData);
-}
-function generateServiceFiles(locations) {
-    const services = Object.values(services_store_1.serviceStore.services);
-    const filesContent = [];
-    for (const service of services) {
-        const methodsString = service.methods
-            .map((method) => generateMethodString(method))
-            .join("\n\n");
-        const templateParams = {
-            name: service.name.replace("Service", ""),
-            baseUrl: service.baseUrl,
-            methods: methodsString,
-            imports: service.imports.join(", "),
-            hasHttpParamsHandler: service.methods.some((m) => m.parameters.some((p) => p.in === "query")),
-        };
-        // If imports are empty, we might want to clean up the template later,
-        // but for now we follow the existing template structure.
-        filesContent.push({
-            location: ["services", ...(locations?.[service.name] ?? [])],
-            name: (0, string_utils_1.toKebabCase)(service.name.replace("Service", "")) + ".service",
-            content: (0, angular_template_1.angularServiceTemplate)(templateParams),
-            extension: "ts",
-        });
-    }
-    return filesContent;
-}
-function generateMethodString(method) {
-    const paramsSignature = method.parameters
-        .map((p) => `${p.name}${p.required ? "" : "?"}: ${p.type}`)
-        .join(", ");
-    const httpMethod = method.method.toLowerCase();
-    const responseType = method.responseType;
-    // Convert {id} to ${id} in path
-    let path = method.path.replace(/{([^}]+)}/g, "${$1}");
-    if (!path.startsWith("`")) {
-        // Remove the first $
-        path = `\`${path.slice(1)}\``;
-    }
-    let body = "";
-    const queryParam = method.parameters.find((p) => p.in === "query");
-    if (queryParam) {
-        body += `    const params = HttpHelper.toHttpParams(${queryParam.name} ?? {});\n`;
-    }
-    const options = [];
-    if (queryParam)
-        options.push("params");
-    if (responseType === "Blob" || responseType === "File") {
-        options.push("responseType: 'blob'");
-    }
-    if (httpMethod === "delete" &&
-        method.parameters.some((p) => p.in === "body")) {
-        options.push("body: " + method.parameters.find((p) => p.in === "body")?.name);
-    }
-    const optionsString = options.length > 0 ? `, { ${options.join(", ")} }` : "";
-    if (httpMethod === "get" || httpMethod === "delete") {
-        body += `    return this.http.${httpMethod}<${responseType}>(${path}${optionsString});`;
-    }
-    else {
-        // post, put, patch
-        const dataParam = method.parameters.find((p) => p.in === "body")?.name || "null";
-        body += `    return this.http.${httpMethod}<${responseType}>(${path}, ${dataParam}${optionsString});`;
-    }
-    return `${method.comments}\n  public ${method.name}(${paramsSignature}): Observable<${responseType}> {
-${body}
-  }`;
-}
-function buildMethods(groupedPath) {
-    const methods = [];
-    const pathData = swagger_store_1.swaggerStore.getPaths();
-    const usedNames = [];
-    for (const path of groupedPath.paths) {
-        if (!pathData || !pathData[path])
-            continue;
-        for (const [httpMethod, pathInfo] of Object.entries(pathData[path])) {
-            if (typeof pathInfo !== "object")
-                continue;
-            const method = buildMethod(path, httpMethod, pathInfo, groupedPath, usedNames);
-            methods.push(method);
-            usedNames.push(method.name);
-        }
-    }
-    return methods;
-}
-function buildMethod(path, httpMethod, pathInfo, groupedPath, usedNames) {
-    const baseUrl = groupedPath.baseUrl;
-    const extraSegments = (0, path_utils_1.getExtraSegments)(path, baseUrl).join("/");
-    const methodPath = extraSegments
-        ? `\${this.baseUrl}/${extraSegments}`
-        : `\${this.baseUrl}`;
-    const responseType = getMethodResponseType(pathInfo);
-    const parameters = getMethodParameters(path, httpMethod, pathInfo, groupedPath);
-    const method = {
-        name: computeName(path, httpMethod, usedNames),
-        path: methodPath,
-        method: httpMethod,
-        parameters: parameters,
-        responseType: responseType,
-        comments: (0, generate_comments_1.generateServiceComments)(pathInfo.summary || "", responseType, parameters),
-    };
-    return method;
-}
-function getMethodResponseType(pathInfo) {
-    const responses = pathInfo.responses;
-    if (!responses)
-        return "void";
-    const successResponse = responses["200"] || responses["201"] || responses["default"];
-    if (!successResponse)
-        return "void";
-    if ((0, type_guard_1.isReference)(successResponse)) {
-        return "any";
-    }
-    const content = successResponse.content;
-    if (!content || !content["application/json"])
-        return "void";
-    const schema = content["application/json"].schema;
-    if (!schema)
-        return "void";
-    return (0, build_types_1.switchTypeJson)(schema);
-}
-function getMethodParameters(path, httpMethod, pathInfo, groupedPath) {
-    const parameters = [];
-    const openApiParameters = pathInfo.parameters || [];
-    // Path parameters
-    openApiParameters.forEach((param) => {
-        if ((0, type_guard_1.isReference)(param))
-            return;
-        if (param.in === "path") {
-            parameters.push({
-                name: param.name,
-                in: "path",
-                required: param.required || false,
-                type: (0, build_types_1.switchTypeJson)(param.schema),
-            });
-        }
-    });
-    // Query parameters (grouped)
-    const queryParams = openApiParameters.filter((param) => !(0, type_guard_1.isReference)(param) && param.in === "query");
-    if (queryParams.length > 0) {
-        parameters.push({
-            name: "parameters",
-            in: "query",
-            required: queryParams.some((p) => p.required),
-            type: (0, generate_interface_1.computeParametersName)(httpMethod, path, groupedPath),
-        });
-    }
-    // Request Body
-    if (pathInfo.requestBody) {
-        let bodyType = "any";
-        if ((0, type_guard_1.isReference)(pathInfo.requestBody)) {
-            bodyType = pathInfo.requestBody.$ref.split("/").pop();
-        }
-        else {
-            const content = pathInfo.requestBody.content;
-            if (content && content["application/json"]) {
-                const schema = content["application/json"].schema;
-                if (schema) {
-                    bodyType = (0, build_types_1.switchTypeJson)(schema);
-                }
-            }
-        }
-        parameters.push({
-            name: "data",
-            in: "body",
-            required: true,
-            type: bodyType,
-        });
-    }
-    return parameters;
-}
-function computeName(path, httpMethod, usedNames) {
-    const dict = {
-        get: "get",
-        post: "create",
-        put: "update",
-        delete: "delete",
-        patch: "patch",
-    };
-    const parts = path.split("/").filter((p) => p);
-    const endsInVariable = (0, path_utils_1.isVariable)(parts[parts.length - 1]);
-    if (endsInVariable) {
-        const name = dict[httpMethod];
-        if (usedNames.includes(name)) {
-            return name + (0, string_utils_1.kebabToPascalCase)(parts[parts.length - 2]);
-        }
-        return name;
-    }
-    if (httpMethod === "get" || httpMethod === "put" || httpMethod === "patch") {
-        let name = dict[httpMethod] + "All";
-        if (!usedNames.includes(name)) {
-            return name;
-        }
-        name = dict[httpMethod] + (0, string_utils_1.kebabToPascalCase)(parts[parts.length - 1]);
-        if (!usedNames.includes(name)) {
-            return name;
-        }
-        return dict[httpMethod] + "By" + (0, string_utils_1.kebabToPascalCase)(parts[parts.length - 1]);
-    }
-    if (httpMethod === "post") {
-        let name = dict[httpMethod];
-        if (!usedNames.includes(name)) {
-            return name;
-        }
-        name = (0, string_utils_1.kebabToPascalCase)(parts[parts.length - 1]);
-        if (!usedNames.includes(name)) {
-            return name;
-        }
-        name = "createBy" + (0, string_utils_1.kebabToPascalCase)(parts[parts.length - 1]);
-        if (!usedNames.includes(name)) {
-            return name;
-        }
-        return "create" + (0, string_utils_1.kebabToPascalCase)(parts[parts.length - 1]);
-    }
-    const name = dict[httpMethod];
-    if (usedNames.includes(name)) {
-        return name + (0, string_utils_1.kebabToPascalCase)(parts[parts.length - 1]);
-    }
-    return name + "By" + (0, string_utils_1.kebabToPascalCase)(parts[parts.length - 1]);
-}

package/dist/models/file-content.js

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

package/dist/models/grouped-paths.js

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

package/dist/models/interface-data.js

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