@nestia/sdk 14.0.0 → 14.0.2

package/src/utils/TemporaryDirectory.ts

@@ -0,0 +1,108 @@
+import fs from "fs";
+import path from "path";
+
+/**
+ * Owns unique temporary directories created by this SDK process.
+ *
+ * Shared parent directories are never registered for deletion. Configuration
+ * modules and runtime modules use the same registry and termination hook, so
+ * one process cannot sweep another process's live compiler inputs.
+ *
+ * @evidence contracts/common.md#principled-implementation Only mkdtemp results created by this process enter the registry; cleanup visits those exact directories and leaves shared parents and sibling processes' directories alone.
+ * @evidence contracts/common.md#clear-and-simple-design Creation and explicit release share one private registry and one exit/signal hook for configuration and runtime materialization.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Ownership is established by creation rather than a directory-name pattern, process ID guess or sweeping the entire project cache.
+ * @evidence contracts/common.md#meaningful-documentation The comment defines ownership, shared-parent preservation and why both compiler paths use one registry.
+ * @evidence contracts/portability.md#os-neutral-implementation Node fs/path operations create and remove native paths. The shared hook sweeps all registered directories before re-raising a termination signal; abrupt OS termination can bypass JavaScript cleanup.
+ * efficient algorithms: Set membership and registration are constant-time on average; a termination sweep visits each retained directory once and removal costs the owned subtree's filesystem entries. Shared parents are never scanned.
+ * reuse equivalent work: Configuration and runtime materializers share the same registry and once-installed exit/signal hooks. Each child has distinct contents and ownership, so allocations and deletions themselves are not substituted by a cached path.
+ * bound retention and release resources: The registry retains one path per unreleased materialization; explicit release forgets it and process termination sweeps the remainder. Failed removals are reported and cause a failing exit rather than hiding them.
+ */
+export namespace TemporaryDirectory {
+  /**
+   * Creates and registers an owned child under a possibly shared parent.
+   *
+   * @evidence contracts/common.md#principled-implementation mkdir establishes the parent and mkdtemp creates an exclusive child before its path is registered, so concurrent processes never acquire ownership of the same directory.
+   * @evidence contracts/common.md#clear-and-simple-design The function creates one child and registers the shared cleanup hook once.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts The random child is allocated by the filesystem; no shared parent is eligible for cleanup and existing signal listeners do not suppress this registration.
+   * @evidence contracts/common.md#meaningful-documentation The comment states that the returned child is owned and its parent may be shared.
+   * @evidence contracts/portability.md#os-neutral-implementation Node mkdir/mkdtemp and path.join operate on filesystem paths supplied by the materializers; no URL spelling, separator literal or OS-specific shell creates the child. Signal delivery remains best effort under abrupt termination.
+   * efficient algorithms: The function makes one filesystem allocation and one average constant-time Set insertion; parent creation follows its path depth, and the fixed termination hooks are installed only on the first allocation.
+   * reuse equivalent work: All create calls reuse the one cleanup-hook registration. Directory allocations cannot be shared because each compiler materialization needs independent mutable contents and deletion ownership.
+   * bound retention and release resources: Each returned child transfers its contents to the caller while its path remains registered until explicit remove or process termination. Retention grows with unreleased materializations; process exit bounds the registry lifetime but a long-running process has no independent byte/count limit.
+   */
+  export const create = (parent: string, prefix: string): string => {
+    fs.mkdirSync(parent, { recursive: true });
+    const directory: string = fs.mkdtempSync(path.join(parent, prefix));
+    owned.add(directory);
+    if (!registered) {
+      registered = true;
+      process.once("exit", sweep);
+      for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"] as const)
+        process.once(signal, () => {
+          sweep();
+          process.kill(process.pid, signal);
+        });
+    }
+    return directory;
+  };
+
+  /**
+   * Releases a registered child early; an unowned path is rejected.
+   *
+   * @evidence contracts/common.md#principled-implementation Registry membership is required before recursive removal, and ownership is forgotten only after removal succeeds; an arbitrary or already released path cannot be deleted through this operation.
+   * @evidence contracts/common.md#clear-and-simple-design One membership guard, one removal and one registry deletion own explicit release.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts It never broadens the requested deletion to the parent and does not swallow filesystem errors.
+   * @evidence contracts/common.md#meaningful-documentation The comment identifies early release and rejection of unowned paths.
+   * @evidence contracts/portability.md#os-neutral-implementation The returned native path is an ownership token checked by exact Set membership before Node recursive removal; alternate spellings are rejected rather than guessing filesystem case identity or invoking a platform shell.
+   * efficient algorithms: One average constant-time ownership lookup/deletion surrounds removal proportional to that child's filesystem subtree; siblings and shared parents are neither enumerated nor removed.
+   * reuse equivalent work: A deletion is a one-time ownership-consuming effect, not a reusable computation. Explicit releases unregister children so the shared termination sweep does not repeat their removals.
+   * bound retention and release resources: Successful removal releases contents and registry identity together; a failed removal retains ownership for later cleanup and propagates the error. Termination cleanup attempts other retained children and reports failures.
+   */
+  export const remove = (directory: string): void => {
+    if (!owned.has(directory))
+      throw new Error(`Unowned temporary directory: ${directory}`);
+    fs.rmSync(directory, { recursive: true, force: true });
+    owned.delete(directory);
+  };
+
+  /**
+   * Releases all materializations owned by a completed disposable generation.
+   *
+   * Every child is attempted even when another removal fails; failed ownership
+   * remains registered for the termination hook to attempt again.
+   *
+   * @evidence contracts/common.md#principled-implementation The snapshot contains only registered mkdtemp results and remove checks ownership again; all children are attempted and aggregate failure prevents reporting successful cleanup.
+   * @evidence contracts/common.md#clear-and-simple-design One loop delegates deletion to the existing ownership-consuming operation and collects only removal errors.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts Shared parents and foreign directories never enter this cleanup, and a failed removal is retained and reported rather than forgotten.
+   * @evidence contracts/common.md#meaningful-documentation The comment states generation-end release, continuation after a failed deletion and retained ownership for termination cleanup.
+   * @evidence contracts/portability.md#os-neutral-implementation The existing native fs/path removal operation handles each exact registered directory; no shell or platform-dependent signal is needed for explicit generation completion.
+   * efficient algorithms: The loop visits each currently owned child once and stores only failed removals; filesystem cost follows their subtrees rather than the shared parent contents.
+   * reuse equivalent work: Explicit disposal consumes ownership, so the later shared exit hook sees no successfully released child and cannot repeat equivalent removals.
+   * bound retention and release resources: Successful completion releases every owned directory and registry entry before the worker reports its result. Failed entries remain owned and an AggregateError propagates the unresolved cleanup.
+   */
+  export const dispose = (): void => {
+    const errors: unknown[] = [];
+    for (const directory of [...owned])
+      try {
+        remove(directory);
+      } catch (error) {
+        errors.push(error);
+      }
+    if (errors.length)
+      throw new AggregateError(errors, "SDK temporary cleanup failed.");
+  };
+}
+
+const owned: Set<string> = new Set();
+let registered = false;
+const sweep = (): void => {
+  for (const directory of owned)
+    try {
+      TemporaryDirectory.remove(directory);
+    } catch (error) {
+      process.stderr.write(
+        `Failed to remove SDK temporary directory: ${String(error)}\n`,
+      );
+      process.exitCode = 1;
+    }
+};

package/src/utils/TsConfigReader.ts

@@ -1,49 +1,125 @@
 import fs from "fs";
 import path from "path";
 
+/**
+ * Reads a tsconfig with its `extends` chain without the compiler API.
+ *
+ * Later bases override earlier bases, including shared ancestors. Circular
+ * inheritance rejects rather than returning a partial configuration.
+ *
+ * @evidence contracts/common.md#principled-implementation The file is read as JSON with comments and trailing commas removed, each base is resolved and merged before the file itself, active ancestors reject cycles, and the relative `typeRoots` of each file are resolved against that file's own directory, as the compiler resolves them, before the merge forgets where they came from.
+ * @evidence contracts/common.md#clear-and-simple-design One public function with private parsing and resolution helpers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts It reads the files the compiler reads.
+ * @evidence contracts/common.md#meaningful-documentation The comment states its purpose.
+ * @evidence contracts/portability.md#os-neutral-implementation Files are read as UTF-8 through `fs`, a leading byte order mark is dropped, relative bases and `typeRoots` are resolved with `path.resolve` against the directory of the file that names them, and package bases go through Node module resolution from that directory. Resolved native path spellings key the per-read cache and active-ancestor set. Relative bases and option paths retain the directory of the requested config rather than being rebased onto a symlink target.
+ * efficient algorithms: Each distinct resolved configuration is parsed and merged once per read. Every extends edge contributes its already-merged options in declared order; work scales with input bytes, edges and the option records being combined rather than repeated traversal of shared ancestry.
+ * reuse equivalent work: A read owns a cache of completed results keyed by resolved config pathname. It shares the same base across branches only within that read, and a later read observes edits rather than retaining stale configuration state.
+ * bound retention and release resources: The active-ancestor set and completed-config map belong to one read. Active entries leave in finally, and the map is released when the returned read promise settles; no process-wide cache or open file handle survives.
+ */
 export namespace TsConfigReader {
+  /**
+   * A tsconfig: its `extends` and its compiler options.
+   *
+   * @evidence contracts/common.md#principled-implementation The record has the two members the loader reads.
+   * @evidence contracts/common.md#clear-and-simple-design A two-member record.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts It is a type and adds no runtime behavior.
+   * @evidence contracts/common.md#meaningful-documentation The comment names the members.
+   * @evidenceExclude contracts/portability.md#os-neutral-implementation The record holds parsed option values and opens no path or process of its own.
+   * efficient algorithms: The record represents config options and chooses no computation.
+   * reuse equivalent work: The record coordinates no reads or reuse.
+   * bound retention and release resources: The record owns no cache, task or filesystem handle.
+   */
   export interface ITsConfig {
     extends?: string | string[];
     compilerOptions?: Record<string, any>;
   }
 
+  /**
+   * Returns the merged tsconfig of a file: bases first, later files override
+   * earlier ones, and compiler options are merged by key. The `typeRoots` of a
+   * file are returned absolute, resolved against the directory of the file that
+   * wrote them.
+   *
+   * @evidence contracts/common.md#principled-implementation Relative bases are resolved from the file's directory and package bases through module resolution, a base that cannot be found is skipped, and completed base configurations are reused by resolved pathname, and only a revisit to an active ancestor is a rejected cycle. A shared base contributes its full inherited values to every branch, so later extends entries override earlier ones even in a diamond.
+   * @evidence contracts/common.md#clear-and-simple-design One function delegating the merge.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts The comment stripper and the trailing-comma remover are one-pass scanners that track strings, so a slash or a comma inside a string value is kept; the files are read as the compiler reads them, apart from the stated limit that only `typeRoots` is rebased and the other path-valued options keep their written form.
+   * @evidence contracts/common.md#meaningful-documentation The comment states the merge order.
+   * @evidence contracts/portability.md#os-neutral-implementation The `typeRoots` of the result are absolute native paths, but every other path-valued option keeps its written form relative to the directory of the file that wrote it, so a caller must not read such an option as relative to its own directory.
+   * efficient algorithms: One per-read completed map avoids re-reading and recursively merging shared ancestors, while each direct base's option record is combined in order to preserve last-base precedence.
+   * reuse equivalent work: Completed ancestors share their parsed and merged values within this request. Each call starts fresh state because files can change between generations.
+   * bound retention and release resources: The call allocates its own ancestor set and result map and retains neither globally. Each recursive active entry is removed in finally, including parse and resolution failures.
+   */
   export const read = async (file: string): Promise<ITsConfig> =>
-    merge(file, new Set());
+    merge(file, new Set(), new Map());
 
   const merge = async (
     file: string,
-    visited: Set<string>,
+    active: Set<string>,
+    completed: Map<string, ITsConfig>,
   ): Promise<ITsConfig> => {
     const location: string = path.resolve(file);
-    if (visited.has(location)) return {};
-    visited.add(location);
+    if (active.has(location))
+      throw new Error(`Circular tsconfig extends: ${location}`);
+    const cached: ITsConfig | undefined = completed.get(location);
+    if (cached !== undefined) return cached;
+    active.add(location);
 
-    const current: ITsConfig = parse(
-      await fs.promises.readFile(location, "utf8"),
-    );
-    const bases: ITsConfig[] = [];
-    for (const parent of asArray(current.extends)) {
-      const next: string | null = resolveExtends(
-        parent,
+    try {
+      const current: ITsConfig = rebase(
+        parse(await fs.promises.readFile(location, "utf8")),
         path.dirname(location),
       );
-      if (next !== null) bases.push(await merge(next, visited));
+      const bases: ITsConfig[] = [];
+      for (const parent of asArray(current.extends)) {
+        const next: string | null = resolveExtends(
+          parent,
+          path.dirname(location),
+        );
+        if (next !== null) bases.push(await merge(next, active, completed));
+      }
+      const result = [...bases, current].reduce<ITsConfig>(
+        (acc, elem) => ({
+          ...acc,
+          ...elem,
+          compilerOptions: {
+            ...(acc.compilerOptions ?? {}),
+            ...(elem.compilerOptions ?? {}),
+          },
+        }),
+        {},
+      );
+      completed.set(location, result);
+      return result;
+    } finally {
+      active.delete(location);
     }
-    return [...bases, current].reduce<ITsConfig>(
-      (acc, elem) => ({
-        ...acc,
-        ...elem,
-        compilerOptions: {
-          ...(acc.compilerOptions ?? {}),
-          ...(elem.compilerOptions ?? {}),
-        },
-      }),
-      {},
-    );
   };
 
+  // The compiler reads a relative path of a config against the directory of the
+  // file that wrote it, and the merged result no longer says which file that
+  // was, so `typeRoots`, the one path-valued option a caller forwards to another
+  // project, is made absolute here.
+  const rebase = (config: ITsConfig, directory: string): ITsConfig => {
+    const typeRoots: unknown = config.compilerOptions?.typeRoots;
+    if (Array.isArray(typeRoots) === false) return config;
+    return {
+      ...config,
+      compilerOptions: {
+        ...config.compilerOptions,
+        typeRoots: (typeRoots as unknown[]).map((root) =>
+          typeof root === "string" ? path.resolve(directory, root) : root,
+        ),
+      },
+    };
+  };
+
+  // A byte order mark, which editors on some platforms write, is no JSON.
   const parse = (text: string): ITsConfig =>
-    JSON.parse(stripTrailingCommas(stripJsonComments(text))) as ITsConfig;
+    JSON.parse(
+      stripTrailingCommas(
+        stripJsonComments(text.charCodeAt(0) === 0xfeff ? text.slice(1) : text),
+      ),
+    ) as ITsConfig;
 
   const asArray = <T>(value: T | T[] | undefined): T[] =>
     value === undefined ? [] : Array.isArray(value) ? value : [value];
@@ -111,6 +187,28 @@ export namespace TsConfigReader {
     return output;
   };
 
-  const stripTrailingCommas = (input: string): string =>
-    input.replace(/,\s*([}\]])/g, "$1");
+  // a comma followed, past whitespace, by a closing brace or bracket, outside
+  // every string, so that the text of a value is never changed
+  const stripTrailingCommas = (input: string): string => {
+    let output = "";
+    let string: false | '"' | "'" = false;
+    let escaped = false;
+    for (let i = 0; i < input.length; ++i) {
+      const ch = input[i]!;
+      if (string !== false) {
+        output += ch;
+        if (escaped) escaped = false;
+        else if (ch === "\\") escaped = true;
+        else if (ch === string) string = false;
+      } else if (ch === '"' || ch === "'") {
+        string = ch;
+        output += ch;
+      } else if (ch === ",") {
+        let next = i + 1;
+        while (next < input.length && /\s/.test(input[next]!)) ++next;
+        if (input[next] !== "}" && input[next] !== "]") output += ch;
+      } else output += ch;
+    }
+    return output;
+  };
 }

package/src/utils/TtscExecutor.ts

@@ -2,13 +2,35 @@ import cp from "child_process";
 import fs from "fs";
 import path from "path";
 
+/**
+ * Runs the `ttsc` compiler of the project.
+ *
+ * @evidence contracts/common.md#principled-implementation The binary is found from the project's own `ttsc` package, with the SDK's dependency as a fallback, and is run with the current Node.
+ * @evidence contracts/common.md#clear-and-simple-design One function and a resolution cache.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The binary comes from the package manifest, not a fixed path.
+ * @evidence contracts/common.md#meaningful-documentation The comment states its purpose.
+ * @evidence contracts/portability.md#os-neutral-implementation The compiler runs as a child of the current Node executable (`process.execPath`) on the JavaScript entry that the package manifest's `bin` names, found through Node module resolution from the project directory, so no platform shim (`.cmd`, `.ps1` or shell script) and no `PATH` lookup is involved. Arguments are an array, never a command line, and the entry path is joined with `path.join` and checked with `existsSync`.
+ */
 export namespace TtscExecutor {
+  /**
+   * Compiles a project with `ttsc` and returns captured output, or null when
+   * the selected stdio does not pipe standard output.
+   *
+   * The cache directory of the environment is passed on, and a non-zero exit
+   * throws.
+   *
+   * @evidence contracts/common.md#principled-implementation The command is run with an argument array and the current Node executable, so no shell or platform shim is involved.
+   * @evidence contracts/common.md#clear-and-simple-design One function.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts The environment is extended, not replaced.
+   * @evidence contracts/common.md#meaningful-documentation The comment states the arguments and the failure.
+   * @evidence contracts/portability.md#os-neutral-implementation The working directory and the environment are explicit. Standard output is piped by default with a 64 MiB buffer; callers may select another stdio mode. A non-zero exit surfaces as Node's process error carrying `status` and available captured output.
+   */
   export const run = (props: {
     cwd: string;
     env?: NodeJS.ProcessEnv;
     project: string;
     stdio?: cp.StdioOptions;
-  }): Buffer => {
+  }): Buffer | null => {
     const args: string[] = [bin(props.cwd), "-p", props.project];
     if (process.env.TTSC_CACHE_DIR !== undefined)
       args.push("--cache-dir", process.env.TTSC_CACHE_DIR);

package/src/utils/VersioningStrategy.ts

@@ -2,27 +2,62 @@ import { VERSION_NEUTRAL, VersionValue } from "@nestjs/common/interfaces";
 
 import { INestiaProject } from "../structures/INestiaProject";
 
+/**
+ * Resolves the URI versions of a controller method as NestJS does.
+ *
+ * @evidence contracts/common.md#principled-implementation The namespace turns version metadata and the default version into path segments.
+ * @evidence contracts/common.md#clear-and-simple-design Two functions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The precedence is NestJS's.
+ * @evidence contracts/common.md#meaningful-documentation The comment states its purpose.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation VersioningStrategy maps Nest version metadata to URI segments, which are protocol spelling rather than native file paths.
+ */
 export namespace VersioningStrategy {
+  /**
+   * Casts version metadata to a list: absence stays absent and a single value
+   * is a one-element list.
+   *
+   * @evidence contracts/common.md#principled-implementation A single version becomes a list while absence stays distinct from an explicit empty list, which registers no paths rather than inheriting other versions.
+   * @evidence contracts/common.md#clear-and-simple-design One conditional.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts It adds nothing.
+   * @evidence contracts/common.md#meaningful-documentation The comment states the cases.
+   * @evidenceExclude contracts/portability.md#os-neutral-implementation VersioningStrategy.cast maps Nest version metadata to URI segments, which are protocol spelling rather than native file paths.
+   */
   export const cast = (
     value: VersionValue | undefined,
-  ): Array<string | typeof VERSION_NEUTRAL> =>
-    value === undefined ? [] : Array.isArray(value) ? value : [value];
+  ): Array<string | typeof VERSION_NEUTRAL> | undefined =>
+    value === undefined ? undefined : Array.isArray(value) ? value : [value];
 
+  /**
+   * Version path segments of a route, resolved as NestJS resolves them: the
+   * method's versions, else the controller's, else the default version, and no
+   * version at all is the unversioned path.
+   *
+   * The controller's and the method's versions were joined, so a method
+   * overriding its controller's version was also described at the controller's,
+   * and a route with no version and no default got no path at all (#1735).
+   *
+   * @evidence contracts/common.md#principled-implementation The first present method, controller or default list wins, including an empty list that registers no paths. Duplicates are removed, neutral and absent versions have no segment, and with versioning off the only segment is empty.
+   * @evidence contracts/common.md#clear-and-simple-design One curried function.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts The precedence is NestJS's.
+   * @evidence contracts/common.md#meaningful-documentation The comment states the precedence.
+   * @evidenceExclude contracts/portability.md#os-neutral-implementation VersioningStrategy.merge maps Nest version metadata to URI segments, which are protocol spelling rather than native file paths.
+   */
   export const merge =
     (project: Omit<INestiaProject, "config">) =>
-    (values: Array<string | typeof VERSION_NEUTRAL>): string[] => {
-      if (project.input.versioning === undefined) return [""];
-      const set: Set<string | typeof VERSION_NEUTRAL> = new Set(values);
-      const array: Array<string | typeof VERSION_NEUTRAL> =
-        set.size === 0
-          ? cast(project.input.versioning?.defaultVersion)
-          : Array.from(set);
-      return !!array?.length
-        ? array.map((x) =>
-            typeof x === "symbol"
-              ? ""
-              : `${project.input.versioning!.prefix}${x}`,
-          )
-        : [];
+    (props: {
+      controller: Array<string | typeof VERSION_NEUTRAL> | undefined;
+      method: Array<string | typeof VERSION_NEUTRAL> | undefined;
+    }): string[] => {
+      const versioning = project.input.versioning;
+      if (versioning === undefined) return [""];
+      const chosen: Array<string | typeof VERSION_NEUTRAL> | undefined =
+        props.method ?? props.controller ?? cast(versioning.defaultVersion);
+      if (chosen === undefined) return [""];
+      const unique: Array<string | typeof VERSION_NEUTRAL> = [
+        ...new Set(chosen),
+      ];
+      return unique.map((x) =>
+        typeof x === "symbol" ? "" : `${versioning.prefix}${x}`,
+      );
     };
 }

package/src/validators/TextPlainValidator.ts

@@ -1,6 +1,25 @@
 import { MetadataSchema, sizeOf } from "../internal/legacy";
 
+/**
+ * Validates that a type can be a `text/plain` body or response.
+ *
+ * @evidence contracts/common.md#principled-implementation A plain text body is a string, so the type may hold only string forms.
+ * @evidence contracts/common.md#clear-and-simple-design One function.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The rule follows the content type.
+ * @evidence contracts/common.md#meaningful-documentation The comment states its purpose.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation TextPlainValidator checks the metadata union accepted for a text/plain payload; it owns no native filesystem or executable representation.
+ */
 export namespace TextPlainValidator {
+  /**
+   * Returns an error message unless every member of the metadata is a string, a
+   * string constant, a string template, or the native String.
+   *
+   * @evidence contracts/common.md#principled-implementation The number of string forms is counted and compared with the size of the metadata, so any other form makes the counts differ, and an empty type is also refused.
+   * @evidence contracts/common.md#clear-and-simple-design One function.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts The count is exact and no type is special-cased.
+   * @evidence contracts/common.md#meaningful-documentation The comment states the accepted forms.
+   * @evidenceExclude contracts/portability.md#os-neutral-implementation TextPlainValidator.validate checks the metadata union accepted for a text/plain payload; it owns no native filesystem or executable representation.
+   */
   export const validate = (props: { metadata: MetadataSchema }): string[] => {
     const expected: number =
       props.metadata.atomics.filter((a) => a.type === "string").length +

package/lib/generates/internal/SwaggerReadonlyArrayEmender.d.ts

@@ -1,9 +0,0 @@
-import { OpenApi } from "@typia/interface";
-import { MetadataSchema } from "../../internal/legacy";
-export declare namespace SwaggerReadonlyArrayEmender {
-    const emend: (props: {
-        components: OpenApi.IComponents;
-        schema: OpenApi.IJsonSchema | undefined;
-        metadata: MetadataSchema;
-    }) => void;
-}

package/lib/generates/internal/SwaggerReadonlyArrayEmender.js

@@ -1,178 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwaggerReadonlyArrayEmender = void 0;
-var SwaggerReadonlyArrayEmender;
-(function (SwaggerReadonlyArrayEmender) {
-    SwaggerReadonlyArrayEmender.emend = (props) => {
-        const visited = {
-            aliases: new WeakSet(),
-            arrays: new WeakSet(),
-            objects: new WeakSet(),
-            schemas: new WeakSet(),
-            tuples: new WeakSet(),
-        };
-        visitMetadata({
-            components: props.components,
-            schema: props.schema,
-            metadata: props.metadata,
-            visited,
-        });
-    };
-})(SwaggerReadonlyArrayEmender || (exports.SwaggerReadonlyArrayEmender = SwaggerReadonlyArrayEmender = {}));
-const visitMetadata = (props) => {
-    if (props.schema !== undefined && isReadonlyArrayLike(props.metadata))
-        setReadonlyArray(props.schema);
-    if (props.visited.schemas.has(props.metadata))
-        return;
-    props.visited.schemas.add(props.metadata);
-    for (const array of props.metadata.arrays) {
-        const type = array.type;
-        if (type !== undefined)
-            visitArrayType({
-                components: props.components,
-                schema: arraySchema(props.schema),
-                type,
-                visited: props.visited,
-            });
-    }
-    for (const tuple of props.metadata.tuples) {
-        const type = tuple.type;
-        if (type !== undefined)
-            visitTupleType({
-                components: props.components,
-                schema: props.schema,
-                type,
-                visited: props.visited,
-            });
-    }
-    for (const alias of props.metadata.aliases) {
-        const type = alias.type;
-        if (type !== undefined)
-            visitAliasType({
-                components: props.components,
-                schema: componentSchema(props.components, type.name),
-                type,
-                visited: props.visited,
-            });
-    }
-    for (const object of props.metadata.objects) {
-        const type = object.type;
-        if (type !== undefined)
-            visitObjectType({
-                components: props.components,
-                type,
-                visited: props.visited,
-            });
-    }
-};
-const visitAliasType = (props) => {
-    if (props.visited.aliases.has(props.type))
-        return;
-    props.visited.aliases.add(props.type);
-    if (props.schema !== undefined && isReadonlyArrayLike(props.type.value))
-        setReadonlyArray(props.schema);
-    visitMetadata({
-        components: props.components,
-        schema: props.schema,
-        metadata: props.type.value,
-        visited: props.visited,
-    });
-};
-const visitArrayType = (props) => {
-    var _a;
-    if (props.visited.arrays.has(props.type))
-        return;
-    props.visited.arrays.add(props.type);
-    const component = componentSchema(props.components, props.type.name);
-    if (component !== undefined && isReadonlyArrayName(props.type.name))
-        setReadonlyArray(component);
-    visitMetadata({
-        components: props.components,
-        schema: arraySchema((_a = props.schema) !== null && _a !== void 0 ? _a : component),
-        metadata: props.type.value,
-        visited: props.visited,
-    });
-};
-const visitTupleType = (props) => {
-    var _a;
-    if (props.visited.tuples.has(props.type))
-        return;
-    props.visited.tuples.add(props.type);
-    const component = componentSchema(props.components, props.type.name);
-    if (component !== undefined && isReadonlyArrayName(props.type.name))
-        setReadonlyArray(component);
-    const schema = objectSchema((_a = props.schema) !== null && _a !== void 0 ? _a : component);
-    props.type.elements.forEach((metadata, index) => visitMetadata({
-        components: props.components,
-        schema: Array.isArray(schema === null || schema === void 0 ? void 0 : schema.prefixItems)
-            ? schema.prefixItems[index]
-            : undefined,
-        metadata,
-        visited: props.visited,
-    }));
-};
-const visitObjectType = (props) => {
-    if (props.visited.objects.has(props.type))
-        return;
-    props.visited.objects.add(props.type);
-    const schema = objectSchema(componentSchema(props.components, props.type.name));
-    const properties = schema === null || schema === void 0 ? void 0 : schema.properties;
-    for (const property of props.type.properties) {
-        const key = propertyKey(property.key);
-        const child = key === undefined ? undefined : properties === null || properties === void 0 ? void 0 : properties[key];
-        visitMetadata({
-            components: props.components,
-            schema: child,
-            metadata: property.value,
-            visited: props.visited,
-        });
-    }
-};
-const isReadonlyArrayLike = (metadata, visited = new WeakSet()) => {
-    if (visited.has(metadata))
-        return false;
-    visited.add(metadata);
-    const name = metadata.name;
-    return ((typeof name === "string" && isReadonlyArrayName(name)) ||
-        metadata.arrays.some((array) => isReadonlyArrayName(array.name)) ||
-        metadata.tuples.some((tuple) => isReadonlyArrayName(tuple.name)) ||
-        metadata.aliases.some((alias) => {
-            const type = alias.type;
-            return type !== undefined && isReadonlyArrayLike(type.value, visited);
-        }));
-};
-const isReadonlyArrayName = (name) => {
-    const compact = name.replace(/\s+/g, "");
-    // Metadata identity names pass through the generator's name replacer, which
-    // strips TypeScript punctuation for schema-key safety — depending on the
-    // compiler shim, `ReadonlyArray<string>` arrives here as "ReadonlyArray",
-    // "ReadonlyArray<string>", or the stripped "ReadonlyArraystring", and
-    // `readonly string[]` as "readonly string[]" or "readonlystring". Match on
-    // the prefixes that survive every form; this predicate only ever sees names
-    // of array/tuple metadata entries, whose spelling the generator controls
-    // ("readonly" is case-sensitive, so PascalCase user types cannot collide).
-    return compact.startsWith("ReadonlyArray") || compact.startsWith("readonly");
-};
-const componentSchema = (components, name) => { var _a; return ((_a = components.schemas) !== null && _a !== void 0 ? _a : {})[name]; };
-const arraySchema = (schema) => {
-    const obj = objectSchema(schema);
-    return obj === null || obj === void 0 ? void 0 : obj.items;
-};
-const objectSchema = (schema) => typeof schema === "object" && schema !== null
-    ? schema
-    : undefined;
-const propertyKey = (metadata) => {
-    var _a, _b;
-    const value = (_b = (_a = metadata.constants[0]) === null || _a === void 0 ? void 0 : _a.values[0]) === null || _b === void 0 ? void 0 : _b.value;
-    return typeof value === "string"
-        ? value
-        : typeof value === "number"
-            ? String(value)
-            : undefined;
-};
-const setReadonlyArray = (schema) => {
-    const obj = objectSchema(schema);
-    if (obj !== undefined)
-        obj["x-readonly-array"] = true;
-};
-//# sourceMappingURL=SwaggerReadonlyArrayEmender.js.map

package/lib/generates/internal/SwaggerReadonlyArrayEmender.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SwaggerReadonlyArrayEmender.js","sourceRoot":"","sources":["../../../src/generates/internal/SwaggerReadonlyArrayEmender.ts"],"names":[],"mappings":"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"}