@skmtc/core 0.0.793 → 0.0.795

package/script/typescript/PathParams.js

@@ -5,26 +5,216 @@ const Definition_js_1 = require("../dsl/Definition.js");
 const Identifier_js_1 = require("../dsl/Identifier.js");
 const FunctionParameter_js_1 = require("./FunctionParameter.js");
 const toPathTemplate_js_1 = require("./toPathTemplate.js");
+/**
+ * Manages path parameter type definitions and function parameters for API endpoints.
+ *
+ * `PathParams` is a utility class that combines type generation, function parameter
+ * handling, and path templating for OpenAPI path parameters. It creates TypeScript
+ * type definitions for path parameters and generates the corresponding function
+ * parameters that can be used in API client methods.
+ *
+ * This class is essential for generating type-safe API clients where path parameters
+ * are properly typed and validated at compile time. It handles both destructured
+ * parameters (when no argument name is provided) and named parameters.
+ *
+ * ## Key Features
+ *
+ * - **Type Definition Generation**: Creates TypeScript types for path parameters
+ * - **Function Parameter Integration**: Generates properly typed function parameters
+ * - **Path Template Processing**: Converts OpenAPI paths to template literals
+ * - **Destructuring Support**: Handles both named and destructured parameter patterns
+ * - **Context Integration**: Fully integrated with the SKMTC generation pipeline
+ *
+ * @example Basic path parameters with destructuring
+ * ```typescript
+ * import { PathParams } from '@skmtc/core';
+ *
+ * const pathParams = new PathParams({
+ *   context: generateContext,
+ *   typeName: 'GetUserParams',
+ *   typeValue: {
+ *     type: 'object',
+ *     objectProperties: {
+ *       properties: {
+ *         id: { type: 'string' },
+ *         format: { type: 'string' }
+ *       }
+ *     }
+ *   },
+ *   pathTemplate: '/users/{id}'
+ * });
+ *
+ * console.log(pathParams.path); // '/users/${id}'
+ * ```
+ *
+ * @example Named parameter usage
+ * ```typescript
+ * const namedPathParams = new PathParams({
+ *   context: generateContext,
+ *   argName: 'params',
+ *   typeName: 'UserPathParams',
+ *   typeValue: {
+ *     type: 'object',
+ *     objectProperties: {
+ *       properties: {
+ *         userId: { type: 'string' },
+ *         projectId: { type: 'string' }
+ *       }
+ *     }
+ *   },
+ *   pathTemplate: '/users/{userId}/projects/{projectId}'
+ * });
+ *
+ * console.log(pathParams.path); // '/users/${params.userId}/projects/${params.projectId}'
+ * ```
+ *
+ * @example API client method generation
+ * ```typescript
+ * class ApiMethodGenerator {
+ *   generateGetMethod(operationPath: string, parameters: any) {
+ *     const pathParams = new PathParams({
+ *       context: this.context,
+ *       argName: 'pathParams',
+ *       typeName: 'PathParameters',
+ *       typeValue: parameters,
+ *       pathTemplate: operationPath
+ *     });
+ *
+ *     return `
+ * async getData(${pathParams.parameter.toString()}) {
+ *   const url = \`${pathParams.path}\`;
+ *   return this.client.get(url);
+ * }`;
+ *   }
+ * }
+ *
+ * // Generates:
+ * // async getData(pathParams: PathParameters) {
+ * //   const url = `/users/${pathParams.userId}/projects/${pathParams.projectId}`;
+ * //   return this.client.get(url);
+ * // }
+ * ```
+ *
+ * @example With destructured parameters
+ * ```typescript
+ * const destructuredParams = new PathParams({
+ *   context: generateContext,
+ *   // No argName provided, so uses destructuring
+ *   typeName: 'OrderParams',
+ *   typeValue: {
+ *     type: 'object',
+ *     objectProperties: {
+ *       properties: {
+ *         orderId: { type: 'string' },
+ *         customerId: { type: 'string' }
+ *       }
+ *     }
+ *   },
+ *   pathTemplate: '/customers/{customerId}/orders/{orderId}'
+ * });
+ *
+ * // Function parameter will be: { orderId, customerId }: OrderParams
+ * // Path template will be: '/customers/${customerId}/orders/${orderId}'
+ * ```
+ *
+ * @example Complex nested path parameters
+ * ```typescript
+ * const complexPathParams = new PathParams({
+ *   context: generateContext,
+ *   argName: 'pathData',
+ *   typeName: 'ComplexPathParams',
+ *   typeValue: {
+ *     type: 'object',
+ *     objectProperties: {
+ *       properties: {
+ *         orgId: { type: 'string' },
+ *         projectId: { type: 'string' },
+ *         issueId: { type: 'number' },
+ *         commentId: { type: 'string' }
+ *       }
+ *     }
+ *   },
+ *   pathTemplate: '/orgs/{orgId}/projects/{projectId}/issues/{issueId}/comments/{commentId}'
+ * });
+ *
+ * // Generates path: '/orgs/${pathData.orgId}/projects/${pathData.projectId}/issues/${pathData.issueId}/comments/${pathData.commentId}'
+ * ```
+ *
+ * @example Integration with operation generation
+ * ```typescript
+ * class OperationGenerator {
+ *   generateOperation(operation: OasOperation) {
+ *     const pathParameters = this.extractPathParameters(operation);
+ *
+ *     if (pathParameters.length > 0) {
+ *       const pathParams = new PathParams({
+ *         context: this.context,
+ *         typeName: `${operation.operationId}PathParams`,
+ *         typeValue: this.buildParametersType(pathParameters),
+ *         pathTemplate: operation.path
+ *       });
+ *
+ *       return this.generateMethodWithPathParams(operation, pathParams);
+ *     }
+ *
+ *     return this.generateSimpleMethod(operation);
+ *   }
+ * }
+ * ```
+ */
 class PathParams {
+    /**
+     * Creates a new PathParams instance with type definitions and path processing.
+     *
+     * The constructor sets up the complete parameter handling pipeline:
+     * 1. Creates a TypeScript type definition for the parameters
+     * 2. Generates a function parameter (either named or destructured)
+     * 3. Processes the path template for runtime interpolation
+     *
+     * @param args - Configuration for path parameter generation
+     *
+     * @example
+     * ```typescript
+     * const pathParams = new PathParams({
+     *   context: generateContext,
+     *   argName: 'params',
+     *   typeName: 'UserPathParams',
+     *   typeValue: {
+     *     type: 'object',
+     *     objectProperties: {
+     *       properties: {
+     *         id: { type: 'string' },
+     *         format: { type: 'string' }
+     *       }
+     *     }
+     *   },
+     *   pathTemplate: '/users/{id}/profile'
+     * });
+     * ```
+     */
     constructor({ context, argName, typeName, typeValue, pathTemplate }) {
+        /** The generation context used for type registration and imports */
         Object.defineProperty(this, "context", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /** The TypeScript type definition for the path parameters */
         Object.defineProperty(this, "typeDefinition", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /** The function parameter representation for method signatures */
         Object.defineProperty(this, "parameter", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /** The processed path template with parameter substitutions */
         Object.defineProperty(this, "path", {
             enumerable: true,
             configurable: true,

package/script/typescript/ReactRouterPathParams.d.ts

@@ -2,18 +2,208 @@ import { ContentBase } from '../dsl/ContentBase.js';
 import type { GenerateContext } from '../context/GenerateContext.js';
 import type { OasOperation } from '../oas/operation/Operation.js';
 import type { GeneratorKey } from '../types/GeneratorKeys.js';
+/**
+ * Constructor arguments for {@link ReactRouterPathParams}.
+ */
 type CreateArgs = {
+    /** The generation context for registering imports and handling dependencies */
     context: GenerateContext;
+    /** The generator key identifying this component */
     generatorKey: GeneratorKey;
+    /** The OpenAPI operation containing path parameters */
     operation: OasOperation;
+    /** The destination file path for import registration */
     destinationPath: string;
 };
+/**
+ * Generates React Router path parameter handling code for OpenAPI operations.
+ *
+ * `ReactRouterPathParams` is a specialized content generator that creates the necessary
+ * React code for extracting and validating path parameters from React Router's `useParams`
+ * hook. It automatically generates parameter extraction, assertion logic, and prop passing
+ * code based on OpenAPI operation path parameters.
+ *
+ * This class is essential for generating type-safe React components that need to access
+ * URL path parameters, ensuring runtime validation and proper TypeScript typing. It
+ * integrates with React Router's `useParams` hook and adds runtime assertions using
+ * the `tiny-invariant` library.
+ *
+ * ## Key Features
+ *
+ * - **Automatic Parameter Extraction**: Generates `useParams()` destructuring code
+ * - **Runtime Assertions**: Creates invariant checks for required parameters
+ * - **Prop Passing**: Generates prop spreading syntax for component integration
+ * - **Import Management**: Automatically registers required imports
+ * - **Type Safety**: Ensures parameters are properly validated at runtime
+ *
+ * @example Basic usage with single path parameter
+ * ```typescript
+ * import { ReactRouterPathParams } from '@skmtc/core';
+ *
+ * const operation = new OasOperation({
+ *   path: '/users/{id}',
+ *   method: 'get',
+ *   // ... other operation properties
+ * });
+ *
+ * const pathParams = new ReactRouterPathParams({
+ *   context: generateContext,
+ *   generatorKey: 'react-router-params',
+ *   operation,
+ *   destinationPath: './UserDetail.tsx'
+ * });
+ *
+ * console.log(pathParams.getParams);
+ * // 'const { id } = useParams()'
+ *
+ * console.log(pathParams.assertParams);
+ * // 'invariant(id, 'Expected id to be defined')'
+ *
+ * console.log(pathParams.passProps);
+ * // 'id={id}'
+ * ```
+ *
+ * @example Multiple path parameters
+ * ```typescript
+ * const complexOperation = new OasOperation({
+ *   path: '/organizations/{orgId}/projects/{projectId}/issues/{issueId}',
+ *   method: 'get',
+ *   // ... other properties
+ * });
+ *
+ * const multiParams = new ReactRouterPathParams({
+ *   context: generateContext,
+ *   generatorKey: 'react-router-params',
+ *   operation: complexOperation,
+ *   destinationPath: './IssueDetail.tsx'
+ * });
+ *
+ * console.log(multiParams.getParams);
+ * // 'const { orgId, projectId, issueId } = useParams()'
+ *
+ * console.log(multiParams.assertParams);
+ * // 'invariant(orgId, 'Expected orgId to be defined')
+ * // invariant(projectId, 'Expected projectId to be defined')
+ * // invariant(issueId, 'Expected issueId to be defined')'
+ *
+ * console.log(multiParams.passProps);
+ * // 'orgId={orgId} projectId={projectId} issueId={issueId}'
+ * ```
+ *
+ * @example Generated React component integration
+ * ```typescript
+ * // Generated component might look like:
+ * import { useParams } from 'react-router-dom';
+ * import invariant from 'tiny-invariant';
+ *
+ * function UserDetail() {
+ *   const { id } = useParams();
+ *   invariant(id, 'Expected id to be defined');
+ *
+ *   return <UserDetailView id={id} />;
+ * }
+ * ```
+ *
+ * @example No path parameters (empty generation)
+ * ```typescript
+ * const simpleOperation = new OasOperation({
+ *   path: '/users',
+ *   method: 'get',
+ *   // ... other properties
+ * });
+ *
+ * const emptyParams = new ReactRouterPathParams({
+ *   context: generateContext,
+ *   generatorKey: 'react-router-params',
+ *   operation: simpleOperation,
+ *   destinationPath: './UserList.tsx'
+ * });
+ *
+ * console.log(emptyParams.getParams);    // ''
+ * console.log(emptyParams.assertParams); // ''
+ * console.log(emptyParams.passProps);    // ''
+ * // No imports registered for this case
+ * ```
+ *
+ * @example Integration in component generation
+ * ```typescript
+ * class ReactComponentGenerator {
+ *   generateDetailComponent(operation: OasOperation) {
+ *     const pathParams = new ReactRouterPathParams({
+ *       context: this.context,
+ *       generatorKey: 'react-component',
+ *       operation,
+ *       destinationPath: this.getDestinationPath(operation)
+ *     });
+ *
+ *     if (pathParams.names.length === 0) {
+ *       // Generate simple component without parameters
+ *       return this.generateSimpleComponent(operation);
+ *     }
+ *
+ *     return `
+ * function ${operation.operationId}() {
+ *   ${pathParams.getParams}
+ *   ${pathParams.assertParams}
+ *
+ *   return (
+ *     <DetailView ${pathParams.passProps} />
+ *   );
+ * }`;
+ *   }
+ * }
+ * ```
+ *
+ * @example Custom parameter validation
+ * ```typescript
+ * class CustomReactRouterParams extends ReactRouterPathParams {
+ *   generateCustomAssertions(paramName: string): string {
+ *     return `
+ * invariant(${paramName}, 'Expected ${paramName} to be defined');
+ * invariant(typeof ${paramName} === 'string', '${paramName} must be a string');
+ * invariant(${paramName}.length > 0, '${paramName} cannot be empty');`;
+ *   }
+ * }
+ * ```
+ */
 export declare class ReactRouterPathParams extends ContentBase {
+    /** Generated code for extracting parameters from useParams() */
     getParams: string;
+    /** Generated code for runtime parameter assertions */
     assertParams: string;
+    /** Generated code for passing parameters as component props */
     passProps: string;
+    /** Array of parameter names extracted from the operation path */
     names: string[];
+    /**
+     * Creates a new ReactRouterPathParams instance with generated parameter handling code.
+     *
+     * The constructor analyzes the OpenAPI operation to extract path parameters and
+     * generates the necessary React code for parameter extraction, validation, and
+     * prop passing. It automatically registers required imports when parameters are present.
+     *
+     * @param args - Configuration for React Router parameter generation
+     *
+     * @example
+     * ```typescript
+     * const pathParams = new ReactRouterPathParams({
+     *   context: generateContext,
+     *   generatorKey: 'react-params',
+     *   operation: userDetailOperation, // has path '/users/{id}'
+     *   destinationPath: './UserDetail.tsx'
+     * });
+     * ```
+     */
     constructor({ context, operation, generatorKey, destinationPath }: CreateArgs);
+    /**
+     * Returns an empty string as this class provides code through its properties.
+     *
+     * The ReactRouterPathParams class doesn't generate output through toString(),
+     * instead providing generated code through the `getParams`, `assertParams`,
+     * and `passProps` properties which can be used directly in template generation.
+     *
+     * @returns Empty string
+     */
     toString(): string;
 }
 export {};

package/script/typescript/ReactRouterPathParams.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactRouterPathParams.d.ts","sourceRoot":"","sources":["../../src/typescript/ReactRouterPathParams.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAE7D,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,eAAe,CAAA;IACxB,YAAY,EAAE,YAAY,CAAA;IAC1B,SAAS,EAAE,YAAY,CAAA;IACvB,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,qBAAa,qBAAsB,SAAQ,WAAW;IACpD,SAAS,EAAE,MAAM,CAAK;IAEtB,YAAY,EAAE,MAAM,CAAK;IAEzB,SAAS,EAAE,MAAM,CAAK;IAEtB,KAAK,EAAE,MAAM,EAAE,CAAA;gBAEH,EAAE,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,eAAe,EAAE,EAAE,UAAU;IAwBpE,QAAQ,IAAI,MAAM;CAG5B"}
+{"version":3,"file":"ReactRouterPathParams.d.ts","sourceRoot":"","sources":["../../src/typescript/ReactRouterPathParams.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAE7D;;GAEG;AACH,KAAK,UAAU,GAAG;IAChB,+EAA+E;IAC/E,OAAO,EAAE,eAAe,CAAA;IACxB,mDAAmD;IACnD,YAAY,EAAE,YAAY,CAAA;IAC1B,uDAAuD;IACvD,SAAS,EAAE,YAAY,CAAA;IACvB,wDAAwD;IACxD,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsJG;AACH,qBAAa,qBAAsB,SAAQ,WAAW;IACpD,gEAAgE;IAChE,SAAS,EAAE,MAAM,CAAK;IAEtB,sDAAsD;IACtD,YAAY,EAAE,MAAM,CAAK;IAEzB,+DAA+D;IAC/D,SAAS,EAAE,MAAM,CAAK;IAEtB,iEAAiE;IACjE,KAAK,EAAE,MAAM,EAAE,CAAA;IAEf;;;;;;;;;;;;;;;;;;OAkBG;gBACS,EAAE,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,eAAe,EAAE,EAAE,UAAU;IAwB7E;;;;;;;;OAQG;IACM,QAAQ,IAAI,MAAM;CAG5B"}

package/script/typescript/ReactRouterPathParams.js

@@ -2,27 +2,201 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReactRouterPathParams = void 0;
 const ContentBase_js_1 = require("../dsl/ContentBase.js");
+/**
+ * Generates React Router path parameter handling code for OpenAPI operations.
+ *
+ * `ReactRouterPathParams` is a specialized content generator that creates the necessary
+ * React code for extracting and validating path parameters from React Router's `useParams`
+ * hook. It automatically generates parameter extraction, assertion logic, and prop passing
+ * code based on OpenAPI operation path parameters.
+ *
+ * This class is essential for generating type-safe React components that need to access
+ * URL path parameters, ensuring runtime validation and proper TypeScript typing. It
+ * integrates with React Router's `useParams` hook and adds runtime assertions using
+ * the `tiny-invariant` library.
+ *
+ * ## Key Features
+ *
+ * - **Automatic Parameter Extraction**: Generates `useParams()` destructuring code
+ * - **Runtime Assertions**: Creates invariant checks for required parameters
+ * - **Prop Passing**: Generates prop spreading syntax for component integration
+ * - **Import Management**: Automatically registers required imports
+ * - **Type Safety**: Ensures parameters are properly validated at runtime
+ *
+ * @example Basic usage with single path parameter
+ * ```typescript
+ * import { ReactRouterPathParams } from '@skmtc/core';
+ *
+ * const operation = new OasOperation({
+ *   path: '/users/{id}',
+ *   method: 'get',
+ *   // ... other operation properties
+ * });
+ *
+ * const pathParams = new ReactRouterPathParams({
+ *   context: generateContext,
+ *   generatorKey: 'react-router-params',
+ *   operation,
+ *   destinationPath: './UserDetail.tsx'
+ * });
+ *
+ * console.log(pathParams.getParams);
+ * // 'const { id } = useParams()'
+ *
+ * console.log(pathParams.assertParams);
+ * // 'invariant(id, 'Expected id to be defined')'
+ *
+ * console.log(pathParams.passProps);
+ * // 'id={id}'
+ * ```
+ *
+ * @example Multiple path parameters
+ * ```typescript
+ * const complexOperation = new OasOperation({
+ *   path: '/organizations/{orgId}/projects/{projectId}/issues/{issueId}',
+ *   method: 'get',
+ *   // ... other properties
+ * });
+ *
+ * const multiParams = new ReactRouterPathParams({
+ *   context: generateContext,
+ *   generatorKey: 'react-router-params',
+ *   operation: complexOperation,
+ *   destinationPath: './IssueDetail.tsx'
+ * });
+ *
+ * console.log(multiParams.getParams);
+ * // 'const { orgId, projectId, issueId } = useParams()'
+ *
+ * console.log(multiParams.assertParams);
+ * // 'invariant(orgId, 'Expected orgId to be defined')
+ * // invariant(projectId, 'Expected projectId to be defined')
+ * // invariant(issueId, 'Expected issueId to be defined')'
+ *
+ * console.log(multiParams.passProps);
+ * // 'orgId={orgId} projectId={projectId} issueId={issueId}'
+ * ```
+ *
+ * @example Generated React component integration
+ * ```typescript
+ * // Generated component might look like:
+ * import { useParams } from 'react-router-dom';
+ * import invariant from 'tiny-invariant';
+ *
+ * function UserDetail() {
+ *   const { id } = useParams();
+ *   invariant(id, 'Expected id to be defined');
+ *
+ *   return <UserDetailView id={id} />;
+ * }
+ * ```
+ *
+ * @example No path parameters (empty generation)
+ * ```typescript
+ * const simpleOperation = new OasOperation({
+ *   path: '/users',
+ *   method: 'get',
+ *   // ... other properties
+ * });
+ *
+ * const emptyParams = new ReactRouterPathParams({
+ *   context: generateContext,
+ *   generatorKey: 'react-router-params',
+ *   operation: simpleOperation,
+ *   destinationPath: './UserList.tsx'
+ * });
+ *
+ * console.log(emptyParams.getParams);    // ''
+ * console.log(emptyParams.assertParams); // ''
+ * console.log(emptyParams.passProps);    // ''
+ * // No imports registered for this case
+ * ```
+ *
+ * @example Integration in component generation
+ * ```typescript
+ * class ReactComponentGenerator {
+ *   generateDetailComponent(operation: OasOperation) {
+ *     const pathParams = new ReactRouterPathParams({
+ *       context: this.context,
+ *       generatorKey: 'react-component',
+ *       operation,
+ *       destinationPath: this.getDestinationPath(operation)
+ *     });
+ *
+ *     if (pathParams.names.length === 0) {
+ *       // Generate simple component without parameters
+ *       return this.generateSimpleComponent(operation);
+ *     }
+ *
+ *     return `
+ * function ${operation.operationId}() {
+ *   ${pathParams.getParams}
+ *   ${pathParams.assertParams}
+ *
+ *   return (
+ *     <DetailView ${pathParams.passProps} />
+ *   );
+ * }`;
+ *   }
+ * }
+ * ```
+ *
+ * @example Custom parameter validation
+ * ```typescript
+ * class CustomReactRouterParams extends ReactRouterPathParams {
+ *   generateCustomAssertions(paramName: string): string {
+ *     return `
+ * invariant(${paramName}, 'Expected ${paramName} to be defined');
+ * invariant(typeof ${paramName} === 'string', '${paramName} must be a string');
+ * invariant(${paramName}.length > 0, '${paramName} cannot be empty');`;
+ *   }
+ * }
+ * ```
+ */
 class ReactRouterPathParams extends ContentBase_js_1.ContentBase {
+    /**
+     * Creates a new ReactRouterPathParams instance with generated parameter handling code.
+     *
+     * The constructor analyzes the OpenAPI operation to extract path parameters and
+     * generates the necessary React code for parameter extraction, validation, and
+     * prop passing. It automatically registers required imports when parameters are present.
+     *
+     * @param args - Configuration for React Router parameter generation
+     *
+     * @example
+     * ```typescript
+     * const pathParams = new ReactRouterPathParams({
+     *   context: generateContext,
+     *   generatorKey: 'react-params',
+     *   operation: userDetailOperation, // has path '/users/{id}'
+     *   destinationPath: './UserDetail.tsx'
+     * });
+     * ```
+     */
     constructor({ context, operation, generatorKey, destinationPath }) {
         super({ context, generatorKey });
+        /** Generated code for extracting parameters from useParams() */
         Object.defineProperty(this, "getParams", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: ''
         });
+        /** Generated code for runtime parameter assertions */
         Object.defineProperty(this, "assertParams", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: ''
         });
+        /** Generated code for passing parameters as component props */
         Object.defineProperty(this, "passProps", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: ''
         });
+        /** Array of parameter names extracted from the operation path */
         Object.defineProperty(this, "names", {
             enumerable: true,
             configurable: true,
@@ -46,6 +220,15 @@ class ReactRouterPathParams extends ContentBase_js_1.ContentBase {
             });
         }
     }
+    /**
+     * Returns an empty string as this class provides code through its properties.
+     *
+     * The ReactRouterPathParams class doesn't generate output through toString(),
+     * instead providing generated code through the `getParams`, `assertParams`,
+     * and `passProps` properties which can be used directly in template generation.
+     *
+     * @returns Empty string
+     */
     toString() {
         return ``;
     }