swaggular 0.2.2 → 0.2.3

package/dist/models/parsed-args.js

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

package/dist/models/service-data.js

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

package/dist/models/types.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AngularRequestType = exports.AngularResponseType = exports.NativeType = void 0;
-var NativeType;
-(function (NativeType) {
-    NativeType["String"] = "string";
-    NativeType["Number"] = "number";
-    NativeType["Boolean"] = "boolean";
-    NativeType["Array"] = "Array";
-    NativeType["Date"] = "Date";
-    NativeType["File"] = "File";
-    NativeType["Any"] = "any";
-    NativeType["Void"] = "void";
-})(NativeType || (exports.NativeType = NativeType = {}));
-var AngularResponseType;
-(function (AngularResponseType) {
-    AngularResponseType["Json"] = "json";
-    AngularResponseType["Text"] = "text";
-    AngularResponseType["Blob"] = "blob";
-    AngularResponseType["ArrayBuffer"] = "arrayBuffer";
-})(AngularResponseType || (exports.AngularResponseType = AngularResponseType = {}));
-var AngularRequestType;
-(function (AngularRequestType) {
-    AngularRequestType["Get"] = "get";
-    AngularRequestType["Post"] = "post";
-    AngularRequestType["Put"] = "put";
-    AngularRequestType["Delete"] = "delete";
-    AngularRequestType["Patch"] = "patch";
-})(AngularRequestType || (exports.AngularRequestType = AngularRequestType = {}));

package/dist/stores/interface-data-store.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.interfaceDataStore = void 0;
-class InterfaceDataStore {
-    genericInterfaces = {};
-    baseInterfaces = {};
-    generatedInterfaces = {};
-    generatedEnums = {};
-    componentsSchemas = {};
-    constructor() { }
-    setComponentsSchemas(componentsSchemas) {
-        this.componentsSchemas = componentsSchemas;
-    }
-    getComponentsSchema(name) {
-        return this.componentsSchemas[name];
-    }
-    exists(name) {
-        return (this.genericInterfaces[name] !== undefined ||
-            this.baseInterfaces[name] !== undefined ||
-            this.generatedInterfaces[name] !== undefined ||
-            this.generatedEnums[name] !== undefined);
-    }
-    addInterfaces(interfacesData) {
-        for (const inter of interfacesData) {
-            this.generatedInterfaces[inter.name] = inter;
-        }
-    }
-    computeExtendsFrom(properties) {
-        if (properties.length === 0)
-            return { extendsFrom: undefined, properties: [] };
-        const currentPropertiesNames = new Set(properties.map((p) => p.name));
-        for (const [name, schema] of Object.entries(this.baseInterfaces)) {
-            if (schema.properties.length !== properties.length)
-                continue;
-            const required = schema.properties
-                .filter((p) => !p.optional)
-                .map((p) => p.name);
-            if (required.some((r) => !currentPropertiesNames.has(r))) {
-                continue;
-            }
-            const optional = schema.properties
-                .filter((p) => p.optional)
-                .map((p) => p.name);
-            const remainingProperties = properties
-                .filter((p) => !required.includes(p.name))
-                .filter((p) => !optional.includes(p.name));
-            if (remainingProperties.length === 0 &&
-                schema.properties.some((p) => p.type === "generic")) {
-                return {
-                    extendsFrom: name,
-                    properties: [],
-                };
-            }
-            return {
-                extendsFrom: name,
-                properties: remainingProperties,
-            };
-        }
-        return { extendsFrom: undefined, properties };
-    }
-}
-exports.interfaceDataStore = new InterfaceDataStore();

package/dist/stores/services-store.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serviceStore = void 0;
-class ServiceStore {
-    services = {};
-    addService(name, content) {
-        this.services[name] = content;
-    }
-    addServices(services) {
-        services.forEach((service) => {
-            this.services[service.name] = service;
-        });
-    }
-    getService(name) {
-        return this.services[name];
-    }
-}
-exports.serviceStore = new ServiceStore();

package/dist/stores/swagger-store.js

@@ -1,324 +0,0 @@
-"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]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.swaggerStore = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const path_utils_1 = require("../utils/path-utils");
-const string_utils_1 = require("../utils/string-utils");
-class SwaggerStore {
-    swagger = undefined;
-    pathsGroupedByScope = undefined;
-    addSwagger(filePath, options = { mode: "tags" }) {
-        const absolutePath = path.resolve(filePath);
-        const content = fs.readFileSync(absolutePath, { encoding: "utf8" });
-        this.swagger = JSON.parse(content);
-        if (!this.swagger)
-            return;
-        this.groupByScopes(this.swagger, options);
-    }
-    getSwagger() {
-        return this.swagger;
-    }
-    getPaths() {
-        return this.swagger?.paths;
-    }
-    getSchemas() {
-        return this.swagger?.components?.schemas;
-    }
-    getPathsGroupedByScope() {
-        return this.pathsGroupedByScope;
-    }
-    getGroupByPath(path) {
-        if (!this.pathsGroupedByScope)
-            return;
-        for (const value of Object.values(this.pathsGroupedByScope)) {
-            if (value.paths.includes(path))
-                return value;
-        }
-        return undefined;
-    }
-    groupByScopes(swagger, options) {
-        this.pathsGroupedByScope = this.groupPaths(swagger.paths, options);
-    }
-    /**
-     * Groups OpenAPI paths based on the specified mode (tags or path).
-     *
-     * @param paths - The OpenAPI paths object to group.
-     * @param options - Configuration for grouping:
-     *  - `mode`: 'tags' to group by OpenAPI tags, or 'path' to group by path segments.
-     *  - `segmentsToIgnore`: (mode 'path' only) Array of path segments to skip during normalization.
-     *  - `ignoreVariables`: (mode 'path' only) Whether to ignore template variables like {id} during grouping.
-     * @returns A record where keys are group names and values are GroupedPath objects.
-     *
-     * @remarks
-     * When in 'path' mode, it creates primary groups using the first non-ignored segment.
-     * If a group contains more than 8 HTTP methods across all its paths, it attempts to
-     * create subgroups for paths that have at least 2 HTTP methods and additional segments.
-     */
-    groupPaths(paths, options = { mode: "tags" }) {
-        if (options.mode === "tags") {
-            return this.groupByTags(paths, options);
-        }
-        else {
-            return this.groupByPath(paths, options);
-        }
-    }
-    groupByTags(paths, options) {
-        const tagGroups = {};
-        const methods = [
-            "get",
-            "put",
-            "post",
-            "delete",
-            "options",
-            "head",
-            "patch",
-            "trace",
-        ];
-        for (const [pathKey, pathItem] of Object.entries(paths)) {
-            if (!pathItem)
-                continue;
-            const tags = new Set();
-            for (const method of methods) {
-                const operation = pathItem[method];
-                if (operation?.tags && operation.tags.length > 0) {
-                    operation.tags.forEach((tag) => tags.add((0, string_utils_1.removeAllWhitespace)(tag)));
-                }
-            }
-            if (tags.size === 0) {
-                const groupKey = "Default";
-                if (!tagGroups[groupKey])
-                    tagGroups[groupKey] = [];
-                tagGroups[groupKey].push(pathKey);
-            }
-            else {
-                tags.forEach((tag) => {
-                    if (!tagGroups[tag])
-                        tagGroups[tag] = [];
-                    tagGroups[tag].push(pathKey);
-                });
-            }
-        }
-        const finalGroups = {};
-        const sortedTags = Object.keys(tagGroups).sort();
-        for (const tagName of sortedTags) {
-            const pathKeys = tagGroups[tagName].sort();
-            const totalMethods = pathKeys.reduce((sum, pk) => sum + this.getMethodCount(paths[pk]), 0);
-            if (totalMethods <= 8) {
-                const groupName = (0, string_utils_1.toPascalCase)([tagName]);
-                finalGroups[groupName] = {
-                    groupName,
-                    baseSegments: this.getCommonSegments(pathKeys),
-                    paths: pathKeys,
-                    baseUrl: (0, path_utils_1.findCommonBaseUrl)(pathKeys),
-                };
-            }
-            else {
-                // Find common segments of this tag group to start splitting from a meaningful depth
-                const commonSegs = this.getCommonSegments(pathKeys);
-                // But we want the group names to start with the TagName
-                this.splitRecursively(paths, pathKeys, commonSegs, options, finalGroups, commonSegs.length, tagName);
-            }
-        }
-        return finalGroups;
-    }
-    groupByPath(paths, options) {
-        const finalGroups = {};
-        const pathKeys = Object.keys(paths).filter((k) => !!paths[k]);
-        // 1. Initial primary grouping by the first non-ignored segment
-        const initialBuckets = {};
-        for (const pk of pathKeys) {
-            const normalized = this.getNormalizedSegments(pk, options);
-            const first = normalized.length > 0 ? normalized[0] : "Default";
-            if (!initialBuckets[first])
-                initialBuckets[first] = [];
-            initialBuckets[first].push(pk);
-        }
-        const sortedPrimaryKeys = Object.keys(initialBuckets).sort();
-        for (const primaryKey of sortedPrimaryKeys) {
-            const pathsInBucket = initialBuckets[primaryKey];
-            const prefix = primaryKey === "Default" ? [] : [primaryKey];
-            this.splitRecursively(paths, pathsInBucket, prefix, options, finalGroups, 0);
-        }
-        // Ensure the resulting groups are deterministic
-        const sortedResult = {};
-        const sortedGroupNames = Object.keys(finalGroups).sort();
-        for (const name of sortedGroupNames) {
-            sortedResult[name] = finalGroups[name];
-        }
-        return sortedResult;
-    }
-    /**
-     * Recursively splits a group of paths based on their segments if the method count threshold is exceeded.
-     */
-    splitRecursively(allPaths, currentPaths, currentPrefix, options, finalGroups, initialDepth, customNamePrefix) {
-        const totalMethods = currentPaths.reduce((sum, pk) => sum + this.getMethodCount(allPaths[pk]), 0);
-        const depth = currentPrefix.length;
-        // Condition 1: If small enough, keep as one group.
-        if (totalMethods <= 8) {
-            this.addToFinalGroups(currentPaths, currentPrefix, finalGroups, initialDepth, customNamePrefix);
-            return;
-        }
-        // Attempt to split.
-        const stayers = [];
-        const branchMap = {};
-        for (const pk of currentPaths) {
-            const normalized = this.getNormalizedSegments(pk, options);
-            if (normalized.length > depth) {
-                const next = normalized[depth];
-                if (!branchMap[next])
-                    branchMap[next] = [];
-                branchMap[next].push(pk);
-            }
-            else {
-                stayers.push(pk);
-            }
-        }
-        const nextSegs = Object.keys(branchMap);
-        // If no possible split (no more segments), stop.
-        if (nextSegs.length === 0) {
-            this.addToFinalGroups(currentPaths, currentPrefix, finalGroups, initialDepth, customNamePrefix);
-            return;
-        }
-        // Identify which branches can move.
-        // A path (or group of paths) can move ONLY if it has >= 2 methods.
-        const movingBranches = [];
-        const remainingToStay = [...stayers];
-        for (const seg of nextSegs) {
-            const paths = branchMap[seg];
-            const count = paths.reduce((sum, pk) => sum + this.getMethodCount(allPaths[pk]), 0);
-            if (count >= 2) {
-                movingBranches.push({ seg, paths });
-            }
-            else {
-                remainingToStay.push(...paths);
-            }
-        }
-        // If no branches can move according to the 2-method rule, stop and keep everything here.
-        if (movingBranches.length === 0) {
-            this.addToFinalGroups(currentPaths, currentPrefix, finalGroups, initialDepth, customNamePrefix);
-            return;
-        }
-        // Optimization: If only one branch can move and no stayers, zip prefix.
-        if (movingBranches.length === 1 && remainingToStay.length === 0) {
-            this.splitRecursively(allPaths, currentPaths, [...currentPrefix, movingBranches[0].seg], options, finalGroups, initialDepth, customNamePrefix);
-            return;
-        }
-        // Otherwise, split: remainingToStay form the group at current level, movingBranches recurse.
-        if (remainingToStay.length > 0) {
-            this.addToFinalGroups(remainingToStay, currentPrefix, finalGroups, initialDepth, customNamePrefix);
-        }
-        for (const branch of movingBranches.sort((a, b) => a.seg.localeCompare(b.seg))) {
-            this.splitRecursively(allPaths, branch.paths, [...currentPrefix, branch.seg], options, finalGroups, initialDepth, customNamePrefix);
-        }
-    }
-    addToFinalGroups(paths, prefix, finalGroups, initialDepth, customNamePrefix) {
-        let groupName;
-        if (customNamePrefix) {
-            const trailing = prefix.slice(initialDepth);
-            groupName = (0, string_utils_1.toPascalCase)([customNamePrefix, ...trailing]);
-        }
-        else {
-            groupName = prefix.length > 0 ? (0, string_utils_1.toPascalCase)(prefix) : "Default";
-        }
-        if (finalGroups[groupName]) {
-            const existing = finalGroups[groupName];
-            existing.paths = [...new Set([...existing.paths, ...paths])].sort();
-            existing.baseSegments = this.getCommonSegments(existing.paths);
-            existing.baseUrl = (0, path_utils_1.findCommonBaseUrl)(existing.paths);
-        }
-        else {
-            finalGroups[groupName] = {
-                groupName,
-                baseSegments: this.getCommonSegments(paths),
-                paths: paths.sort(),
-                baseUrl: (0, path_utils_1.findCommonBaseUrl)(paths),
-            };
-        }
-    }
-    getNormalizedSegments(path, options) {
-        const segments = path.split("/").filter((s) => s);
-        const result = [];
-        for (const segment of segments) {
-            if (options.segmentsToIgnore?.includes(segment))
-                continue;
-            if (options.ignoreVariables && (0, path_utils_1.isVariable)(segment))
-                continue;
-            result.push(segment);
-        }
-        return result;
-    }
-    getMethodCount(pathItem) {
-        const methods = [
-            "get",
-            "put",
-            "post",
-            "delete",
-            "options",
-            "head",
-            "patch",
-            "trace",
-        ];
-        let count = 0;
-        for (const method of methods) {
-            if (pathItem[method]) {
-                count++;
-            }
-        }
-        return count;
-    }
-    getCommonSegments(paths) {
-        if (paths.length === 0)
-            return [];
-        const pathSegments = paths.map((p) => p
-            .replace(/^\/+api\/+/, "")
-            .split("/")
-            .filter((s) => s));
-        const firstPath = pathSegments[0];
-        const common = [];
-        for (let i = 0; i < firstPath.length; i++) {
-            const segment = firstPath[i];
-            if (pathSegments.every((ps) => ps[i] === segment)) {
-                common.push(segment);
-            }
-            else {
-                break;
-            }
-        }
-        return common;
-    }
-}
-exports.swaggerStore = new SwaggerStore();

package/dist/templates/angular-template.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.angularServiceTemplate = void 0;
-const angularServiceTemplate = (params) => {
-    return `
-import { HttpClient } from "@angular/common/http";
-import { Observable } from "rxjs";
-import { inject, Injectable } from '@angular/core';
-import { ${params.imports} } from '../../models';
-import { HttpHelper } from '@umss/shared/utils';
-
-@Injectable({
-    providedIn: "root"
-})
-export class ${params.name}Service {    
-
-  private readonly baseUrl = "${params.baseUrl}";
-  private readonly http = inject(HttpClient);
-
-${params.methods}
-}`;
-};
-exports.angularServiceTemplate = angularServiceTemplate;

package/dist/templates/paged-request-template.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pagedRequestTemplate = void 0;
-exports.pagedRequestTemplate = `
-export interface PagedRequestDto {
-  /**
-   * format: int32
-   * maximum: 2147483647
-   * minimum: 1
-   */
-  pageNumber?: number;
-   /**
-   * format: int32
-   * maximum: 100
-   * minimum: 1
-   */
-  pageSize?: number;
-  searchTerm?: string | null;
-  sortBy?: string | null;
-  sortDescending?: boolean;
-}
-`;

package/dist/templates/paged-result-template.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pagedResultTemplate = void 0;
-exports.pagedResultTemplate = `
-export interface PagedResultDto<T> {
-  items: T[];
-  totalCount: number;
-  pageNumber: number;
-  pageSize: number;
-  totalPages: number;
-  hasPreviousPage: boolean;
-  hasNextPage: boolean;
-}`;

package/dist/translators/add-import-to-interface.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addImportToInterface = addImportToInterface;
-function addImportToInterface(interfaceString, imports, commons, modelInPath) {
-    const commonImports = commons.filter((c) => imports.includes(c));
-    let commonImportString = "";
-    if (commonImports.length > 0) {
-        commonImportString = `import { ${commonImports.join(", ")} } from "../../common";`;
-    }
-    const dtosImports = [];
-    for (const [model, path] of Object.entries(modelInPath)) {
-        if (!path)
-            continue;
-        if (!imports.includes(model))
-            continue;
-        const [outerKey, innerKey] = path;
-        const modelName = innerKey.replace(".dto.ts", "");
-        dtosImports.push(`import { ${modelName} } from "../${outerKey}/${innerKey}";`);
-    }
-    return `${commonImportString.length > 0 ? commonImportString + "\n" : ""}${dtosImports.join("\n")}\n${interfaceString}`;
-}

package/dist/translators/generate-interfaces.js

@@ -1,134 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getImports = getImports;
-exports.buildInterface = buildInterface;
-exports.buildEnum = buildEnum;
-exports.generateSchemaInterfaces = generateSchemaInterfaces;
-exports.buildComments = buildComments;
-const paged_request_template_1 = require("../templates/paged-request-template");
-const paged_result_template_1 = require("../templates/paged-result-template");
-const build_types_1 = require("../utils/build-types");
-const to_case_1 = require("../utils/to-case");
-function getImports(schema, type) {
-    const imports = [];
-    if (!schema["$ref"]) {
-        return [];
-    }
-    if (type.startsWith("PagedResultDto")) {
-        imports.push("PagedResultDto");
-        const splited = type.replaceAll(">", "").split("<");
-        splited.forEach((s) => imports.push(s));
-    }
-    return imports;
-}
-function buildInterface(name, schema) {
-    if (name.endsWith("PagedResultDto"))
-        return { content: null, imports: [] };
-    const lines = [];
-    lines.push(`export interface ${name} {`);
-    const imports = new Set();
-    for (const [prop, def] of Object.entries(schema.properties)) {
-        const comments = buildComments(def);
-        const tsType = (0, build_types_1.switchTypeJson)(def);
-        if (def["$ref"]) {
-            getImports(def, tsType).forEach((i) => imports.add(i));
-        }
-        const optional = def.nullable || !schema.required?.includes(prop);
-        const nullable = def.nullable ? " | null" : "";
-        lines.push(`${comments}\n\t${(0, to_case_1.lowerFirst)(prop)}${optional ? "?" : ""}: ${tsType}${nullable};`);
-    }
-    lines.push(`}`);
-    return { content: lines.join("\n"), imports: [] };
-}
-function buildEnum(name, schema) {
-    const lines = [];
-    lines.push(`export enum ${name} {`);
-    for (const value of schema.enum) {
-        lines.push(`\t${value} = "${value}",`);
-    }
-    lines.push(`}`);
-    return lines.join("\n");
-}
-function generateSchemaInterfaces(schemas, paths, parametersTypes) {
-    const interfaces = {};
-    for (const [name, schema] of Object.entries(schemas)) {
-        if (schema.type === "string" && schema.enum && schema.enum.length > 0) {
-            const enumString = buildEnum(name, schema);
-            if (!enumString)
-                continue;
-            interfaces[name] = { content: enumString, imports: [] };
-            continue;
-        }
-        if (schema.type === "object" && schema.properties) {
-            const interfaceString = buildInterface(name, schema);
-            if (!interfaceString.content)
-                continue;
-            interfaces[name] = {
-                content: interfaceString.content,
-                imports: interfaceString.imports,
-            };
-            continue;
-        }
-    }
-    const defaultPagedRequestDtoKeys = [
-        "pageNumber",
-        "pageSize",
-        "searchTerm",
-        "sortBy",
-        "sortDescending",
-    ];
-    const requestImports = new Set();
-    for (const value of Object.values(parametersTypes)) {
-        const { method, parameterType } = value;
-        const path = paths[method];
-        if (!path.parameters || path.parameters.length === 0)
-            continue;
-        const properties = [];
-        for (const param of path.parameters) {
-            if (defaultPagedRequestDtoKeys.includes(param.name) ||
-                param.in !== "query")
-                continue;
-            const tsType = (0, build_types_1.switchTypeJson)(param.schema);
-            if (param.schema["$ref"]) {
-                getImports(param.schema, tsType).forEach((i) => requestImports.add(i));
-            }
-            const comments = buildComments(param.schema);
-            properties.push(`${comments}\n\t${(0, to_case_1.lowerFirst)(param.name)}?: ${tsType};`);
-        }
-        let interfaceTemplate = `export interface ${parameterType} extends PagedRequestDto {
-      ${properties.join("\n")}
-    }`;
-        requestImports.add("PagedRequestDto");
-        interfaces[parameterType] = {
-            content: interfaceTemplate,
-            imports: Array.from(requestImports),
-        };
-    }
-    return {
-        ...interfaces,
-        ["PagedRequestDto"]: { content: paged_request_template_1.pagedRequestTemplate, imports: [] },
-        ["PagedResultDto"]: { content: paged_result_template_1.pagedResultTemplate, imports: [] },
-    };
-}
-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 "";
-}