@skmtc/core 0.0.983 → 0.16.1

package/esm/typescript/toPathTemplate.js

@@ -1,117 +0,0 @@
-/**
- * Converts OpenAPI path parameters into JavaScript template literal syntax.
- *
- * This utility function transforms OpenAPI path syntax (using curly braces) into
- * JavaScript template literal syntax (using ${} expressions). It's essential for
- * generating URL builders, API client methods, and other dynamic path construction
- * code where OpenAPI path parameters need to be interpolated at runtime.
- *
- * The function supports both simple parameter substitution and qualified parameter
- * access (when parameters come from an object property).
- *
- * @param path - OpenAPI path string with {parameter} syntax
- * @param queryArg - Optional object name to qualify parameter access
- * @returns Template literal string with ${} parameter syntax
- *
- * @example Basic path parameter conversion
- * ```typescript
- * import { toPathTemplate } from '@skmtc/core';
- *
- * const template = toPathTemplate('/users/{id}/posts/{postId}');
- * console.log(template); // '/users/${id}/posts/${postId}'
- *
- * // Usage in generated code:
- * // const url = `/users/${id}/posts/${postId}`;
- * ```
- *
- * @example With query argument qualification
- * ```typescript
- * const template = toPathTemplate('/users/{id}/posts/{postId}', 'params');
- * console.log(template); // '/users/${params.id}/posts/${params.postId}'
- *
- * // Usage in generated code:
- * // function buildUrl(params: {id: string, postId: string}) {
- * //   return `/users/${params.id}/posts/${params.postId}`;
- * // }
- * ```
- *
- * @example API client method generation
- * ```typescript
- * class ApiClientGenerator {
- *   generateMethod(path: string, method: string) {
- *     const template = toPathTemplate(path, 'args');
- *
- *     return `
- * async ${method}(args: PathParams) {
- *   const url = \`${template}\`;
- *   return this.request('${method.toUpperCase()}', url);
- * }`;
- *   }
- * }
- *
- * const generator = new ApiClientGenerator();
- * const method = generator.generateMethod('/users/{userId}/profile', 'getProfile');
- *
- * console.log(method);
- * // async getProfile(args: PathParams) {
- * //   const url = `/users/${args.userId}/profile`;
- * //   return this.request('GET', url);
- * // }
- * ```
- *
- * @example URL builder generation
- * ```typescript
- * function generateUrlBuilder(endpoints: Array<{name: string, path: string}>) {
- *   const builders = endpoints.map(endpoint => {
- *     const template = toPathTemplate(endpoint.path);
- *
- *     return `${endpoint.name}: (${extractParams(endpoint.path)}) => \`${template}\``;
- *   });
- *
- *   return `export const urls = {\n  ${builders.join(',\n  ')}\n};`;
- * }
- *
- * const urlBuilder = generateUrlBuilder([
- *   { name: 'user', path: '/users/{id}' },
- *   { name: 'userPosts', path: '/users/{id}/posts/{postId}' }
- * ]);
- *
- * // Generates:
- * // export const urls = {
- * //   user: (id) => `/users/${id}`,
- * //   userPosts: (id, postId) => `/users/${id}/posts/${postId}`
- * // };
- * ```
- *
- * @example React Router integration
- * ```typescript
- * function generateRouteComponent(path: string, componentName: string) {
- *   const template = toPathTemplate(path, 'params');
- *
- *   return `
- * function ${componentName}() {
- *   const params = useParams();
- *   const apiUrl = \`/api${template}\`;
- *
- *   // Use apiUrl for data fetching
- *   return <div>Content for {apiUrl}</div>;
- * }`;
- * }
- * ```
- *
- * @example Complex nested parameters
- * ```typescript
- * const complexPath = '/organizations/{orgId}/projects/{projectId}/issues/{issueId}/comments/{commentId}';
- *
- * const simple = toPathTemplate(complexPath);
- * console.log(simple);
- * // '/organizations/${orgId}/projects/${projectId}/issues/${issueId}/comments/${commentId}'
- *
- * const qualified = toPathTemplate(complexPath, 'pathParams');
- * console.log(qualified);
- * // '/organizations/${pathParams.orgId}/projects/${pathParams.projectId}/issues/${pathParams.issueId}/comments/${pathParams.commentId}'
- * ```
- */
-export const toPathTemplate = (path, queryArg) => {
-    return `${path.replaceAll(/{([^}]*)}/g, queryArg ? '${' + queryArg + '.$1}' : '${$1}')}`;
-};

package/esm/typescript/withDescription.d.ts

@@ -1,123 +0,0 @@
-import type { Stringable } from '../dsl/Stringable.js';
-import type { Modifiers } from '../types/Modifiers.js';
-/**
- * Wraps a value with a JSDoc comment if a description is provided.
- *
- * This utility function is used throughout the SKMTC code generation system to
- * add JSDoc documentation comments to generated TypeScript code. If a description
- * is provided, it formats it as a single-line JSDoc comment above the value.
- * If no description is provided, the value is returned unchanged.
- *
- * @param value - The code value to potentially wrap with documentation
- * @param modifiers - Modifiers object containing optional description
- * @param modifiers.description - Optional description text for the JSDoc comment
- * @returns The value with JSDoc comment prepended if description exists, otherwise just the value
- *
- * @example With description
- * ```typescript
- * import { withDescription } from '@skmtc/core';
- *
- * const result = withDescription(
- *   'export const API_URL = "https://api.example.com";',
- *   { description: 'Base URL for all API requests' }
- * );
- *
- * console.log(result);
- * // /** Base URL for all API requests *\/
- * // export const API_URL = "https://api.example.com";
- * ```
- *
- * @example Without description
- * ```typescript
- * const result = withDescription(
- *   'export const API_URL = "https://api.example.com";',
- *   { description: undefined }
- * );
- *
- * console.log(result);
- * // export const API_URL = "https://api.example.com";
- * ```
- *
- * @example Using with Definition class
- * ```typescript
- * class ModelGenerator {
- *   generateInterface(name: string, description?: string) {
- *     const interfaceCode = `interface ${name} {
- *   id: string;
- *   name: string;
- * }`;
- *
- *     return withDescription(interfaceCode, { description });
- *   }
- * }
- *
- * const generator = new ModelGenerator();
- * const documented = generator.generateInterface('User', 'Represents a user in the system');
- *
- * console.log(documented);
- * // /** Represents a user in the system *\/
- * // interface User {
- * //   id: string;
- * //   name: string;
- * // }
- * ```
- *
- * @example Integration with generated definitions
- * ```typescript
- * import { Definition, Identifier, withDescription } from '@skmtc/core';
- *
- * class DocumentedGenerator {
- *   createDefinition(name: string, value: string, docs?: string) {
- *     return new Definition({
- *       context: this.context,
- *       identifier: Identifier.createVariable(name),
- *       description: docs, // This gets processed by withDescription internally
- *       value: {
- *         generatorKey: 'documented',
- *         content: value
- *       }
- *     });
- *   }
- * }
- * ```
- *
- * @example Complex documentation
- * ```typescript
- * const complexDoc = withDescription(
- *   `export type Status = 'active' | 'inactive' | 'pending';`,
- *   {
- *     description: 'User account status - active users can access all features'
- *   }
- * );
- *
- * console.log(complexDoc);
- * // /** User account status - active users can access all features *\/
- * // export type Status = 'active' | 'inactive' | 'pending';
- * ```
- *
- * @example Conditional documentation
- * ```typescript
- * function generateWithOptionalDocs(
- *   code: string,
- *   includeDescription: boolean
- * ) {
- *   return withDescription(code, {
- *     description: includeDescription
- *       ? 'This is an auto-generated definition'
- *       : undefined
- *   });
- * }
- *
- * const withDocs = generateWithOptionalDocs('export const VALUE = 42;', true);
- * const withoutDocs = generateWithOptionalDocs('export const VALUE = 42;', false);
- *
- * console.log(withDocs);
- * // /** This is an auto-generated definition *\/
- * // export const VALUE = 42;
- *
- * console.log(withoutDocs);
- * // export const VALUE = 42;
- * ```
- */
-export declare const withDescription: (value: Stringable, { description }: Modifiers) => string;
-//# sourceMappingURL=withDescription.d.ts.map

package/esm/typescript/withDescription.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"withDescription.d.ts","sourceRoot":"","sources":["../../src/typescript/withDescription.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsHG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,UAAU,EACjB,iBAAiB,SAAS,KACzB,MAEF,CAAA"}

package/esm/typescript/withDescription.js

@@ -1,122 +0,0 @@
-/**
- * Wraps a value with a JSDoc comment if a description is provided.
- *
- * This utility function is used throughout the SKMTC code generation system to
- * add JSDoc documentation comments to generated TypeScript code. If a description
- * is provided, it formats it as a single-line JSDoc comment above the value.
- * If no description is provided, the value is returned unchanged.
- *
- * @param value - The code value to potentially wrap with documentation
- * @param modifiers - Modifiers object containing optional description
- * @param modifiers.description - Optional description text for the JSDoc comment
- * @returns The value with JSDoc comment prepended if description exists, otherwise just the value
- *
- * @example With description
- * ```typescript
- * import { withDescription } from '@skmtc/core';
- *
- * const result = withDescription(
- *   'export const API_URL = "https://api.example.com";',
- *   { description: 'Base URL for all API requests' }
- * );
- *
- * console.log(result);
- * // /** Base URL for all API requests *\/
- * // export const API_URL = "https://api.example.com";
- * ```
- *
- * @example Without description
- * ```typescript
- * const result = withDescription(
- *   'export const API_URL = "https://api.example.com";',
- *   { description: undefined }
- * );
- *
- * console.log(result);
- * // export const API_URL = "https://api.example.com";
- * ```
- *
- * @example Using with Definition class
- * ```typescript
- * class ModelGenerator {
- *   generateInterface(name: string, description?: string) {
- *     const interfaceCode = `interface ${name} {
- *   id: string;
- *   name: string;
- * }`;
- *
- *     return withDescription(interfaceCode, { description });
- *   }
- * }
- *
- * const generator = new ModelGenerator();
- * const documented = generator.generateInterface('User', 'Represents a user in the system');
- *
- * console.log(documented);
- * // /** Represents a user in the system *\/
- * // interface User {
- * //   id: string;
- * //   name: string;
- * // }
- * ```
- *
- * @example Integration with generated definitions
- * ```typescript
- * import { Definition, Identifier, withDescription } from '@skmtc/core';
- *
- * class DocumentedGenerator {
- *   createDefinition(name: string, value: string, docs?: string) {
- *     return new Definition({
- *       context: this.context,
- *       identifier: Identifier.createVariable(name),
- *       description: docs, // This gets processed by withDescription internally
- *       value: {
- *         generatorKey: 'documented',
- *         content: value
- *       }
- *     });
- *   }
- * }
- * ```
- *
- * @example Complex documentation
- * ```typescript
- * const complexDoc = withDescription(
- *   `export type Status = 'active' | 'inactive' | 'pending';`,
- *   {
- *     description: 'User account status - active users can access all features'
- *   }
- * );
- *
- * console.log(complexDoc);
- * // /** User account status - active users can access all features *\/
- * // export type Status = 'active' | 'inactive' | 'pending';
- * ```
- *
- * @example Conditional documentation
- * ```typescript
- * function generateWithOptionalDocs(
- *   code: string,
- *   includeDescription: boolean
- * ) {
- *   return withDescription(code, {
- *     description: includeDescription
- *       ? 'This is an auto-generated definition'
- *       : undefined
- *   });
- * }
- *
- * const withDocs = generateWithOptionalDocs('export const VALUE = 42;', true);
- * const withoutDocs = generateWithOptionalDocs('export const VALUE = 42;', false);
- *
- * console.log(withDocs);
- * // /** This is an auto-generated definition *\/
- * // export const VALUE = 42;
- *
- * console.log(withoutDocs);
- * // export const VALUE = 42;
- * ```
- */
-export const withDescription = (value, { description }) => {
-    return description ? `/** ${description} */\n${value}` : `${value}`;
-};