@skmtc/core 0.0.792 → 0.0.793

package/script/helpers/toResolvedArtifactPath.d.ts

@@ -1,8 +1,153 @@
 import "../_dnt.polyfills.js";
+/**
+ * Arguments for resolving artifact file paths.
+ */
 type ToResolvedArtifactPathArgs = {
+    /** The base directory path for resolving relative paths */
     basePath: string | undefined;
+    /** The destination path for the artifact file */
     destinationPath: string;
 };
+/**
+ * Resolves artifact destination paths relative to a base directory.
+ *
+ * This utility function combines a base path with a destination path to create
+ * the final resolved file path for generated artifacts. It handles special path
+ * prefixes (like '@/') and provides sensible defaults when no base path is specified.
+ *
+ * The function is used throughout the rendering pipeline to determine the final
+ * file system locations for generated code artifacts, ensuring consistent path
+ * resolution across different operating systems and deployment scenarios.
+ *
+ * @param args - Path resolution configuration
+ * @param args.basePath - Base directory path (defaults to './' if undefined)
+ * @param args.destinationPath - Destination path for the artifact
+ * @returns The resolved absolute or relative path for the artifact
+ *
+ * @example Basic path resolution
+ * ```typescript
+ * import { toResolvedArtifactPath } from '@skmtc/core';
+ *
+ * // With explicit base path
+ * const resolved1 = toResolvedArtifactPath({
+ *   basePath: './src/generated',
+ *   destinationPath: 'models/User.ts'
+ * });
+ * console.log(resolved1); // './src/generated/models/User.ts'
+ *
+ * // With undefined base path (uses default)
+ * const resolved2 = toResolvedArtifactPath({
+ *   basePath: undefined,
+ *   destinationPath: 'types.ts'
+ * });
+ * console.log(resolved2); // './types.ts'
+ * ```
+ *
+ * @example Special path prefix handling
+ * ```typescript
+ * // '@/' prefix gets stripped and resolved relative to base
+ * const resolved = toResolvedArtifactPath({
+ *   basePath: './output',
+ *   destinationPath: '@/api/models.ts'
+ * });
+ * console.log(resolved); // './output/api/models.ts'
+ *
+ * // Regular paths work normally
+ * const normal = toResolvedArtifactPath({
+ *   basePath: './build',
+ *   destinationPath: 'components/Button.tsx'
+ * });
+ * console.log(normal); // './build/components/Button.tsx'
+ * ```
+ *
+ * @example Cross-platform path resolution
+ * ```typescript
+ * // Works consistently across platforms
+ * const windowsPath = toResolvedArtifactPath({
+ *   basePath: 'C:\\projects\\app\\dist',
+ *   destinationPath: 'utils/helpers.js'
+ * });
+ *
+ * const unixPath = toResolvedArtifactPath({
+ *   basePath: '/home/user/projects/app/dist',
+ *   destinationPath: 'utils/helpers.js'
+ * });
+ * ```
+ *
+ * @example Usage in file generation
+ * ```typescript
+ * class ArtifactWriter {
+ *   writeArtifact(
+ *     content: string,
+ *     destination: string,
+ *     baseDir?: string
+ *   ) {
+ *     const resolvedPath = toResolvedArtifactPath({
+ *       basePath: baseDir,
+ *       destinationPath: destination
+ *     });
+ *
+ *     console.log(`Writing to: ${resolvedPath}`);
+ *     return Deno.writeTextFile(resolvedPath, content);
+ *   }
+ * }
+ *
+ * const writer = new ArtifactWriter();
+ * await writer.writeArtifact(
+ *   'export const greeting = "Hello";',
+ *   '@/constants.ts',
+ *   './src/generated'
+ * );
+ * // Writes to: ./src/generated/constants.ts
+ * ```
+ *
+ * @example Integration with rendering pipeline
+ * ```typescript
+ * class FileRenderer {
+ *   renderFiles(
+ *     files: Map<string, File>,
+ *     outputDir: string
+ *   ): Record<string, string> {
+ *     const artifacts: Record<string, string> = {};
+ *
+ *     for (const [destPath, file] of files) {
+ *       const resolvedPath = toResolvedArtifactPath({
+ *         basePath: outputDir,
+ *         destinationPath: destPath
+ *       });
+ *
+ *       artifacts[resolvedPath] = file.toString();
+ *     }
+ *
+ *     return artifacts;
+ *   }
+ * }
+ * ```
+ *
+ * @example Dynamic base path resolution
+ * ```typescript
+ * function resolveForEnvironment(
+ *   destination: string,
+ *   env: 'development' | 'production'
+ * ): string {
+ *   const basePaths = {
+ *     development: './dev-output',
+ *     production: './dist'
+ *   };
+ *
+ *   return toResolvedArtifactPath({
+ *     basePath: basePaths[env],
+ *     destinationPath: destination
+ *   });
+ * }
+ *
+ * const devPath = resolveForEnvironment('api.ts', 'development');
+ * const prodPath = resolveForEnvironment('api.ts', 'production');
+ *
+ * console.log(devPath);  // './dev-output/api.ts'
+ * console.log(prodPath); // './dist/api.ts'
+ * ```
+ */
 export declare const toResolvedArtifactPath: ({ basePath, destinationPath }: ToResolvedArtifactPathArgs) => string;
 export {};
 //# sourceMappingURL=toResolvedArtifactPath.d.ts.map

package/script/helpers/toResolvedArtifactPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toResolvedArtifactPath.d.ts","sourceRoot":"","sources":["../../src/helpers/toResolvedArtifactPath.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B,KAAK,0BAA0B,GAAG;IAChC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5B,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,eAAO,MAAM,sBAAsB,GAAI,+BAGpC,0BAA0B,KAAG,MAE/B,CAAA"}
+{"version":3,"file":"toResolvedArtifactPath.d.ts","sourceRoot":"","sources":["../../src/helpers/toResolvedArtifactPath.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAG9B;;GAEG;AACH,KAAK,0BAA0B,GAAG;IAChC,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5B,iDAAiD;IACjD,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2IG;AACH,eAAO,MAAM,sBAAsB,GAAI,+BAGpC,0BAA0B,KAAG,MAE/B,CAAA"}

package/script/helpers/toResolvedArtifactPath.js

@@ -3,6 +3,146 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.toResolvedArtifactPath = void 0;
 require("../_dnt.polyfills.js");
 const join_js_1 = require("../deps/jsr.io/@std/path/1.1.2/join.js");
+/**
+ * Resolves artifact destination paths relative to a base directory.
+ *
+ * This utility function combines a base path with a destination path to create
+ * the final resolved file path for generated artifacts. It handles special path
+ * prefixes (like '@/') and provides sensible defaults when no base path is specified.
+ *
+ * The function is used throughout the rendering pipeline to determine the final
+ * file system locations for generated code artifacts, ensuring consistent path
+ * resolution across different operating systems and deployment scenarios.
+ *
+ * @param args - Path resolution configuration
+ * @param args.basePath - Base directory path (defaults to './' if undefined)
+ * @param args.destinationPath - Destination path for the artifact
+ * @returns The resolved absolute or relative path for the artifact
+ *
+ * @example Basic path resolution
+ * ```typescript
+ * import { toResolvedArtifactPath } from '@skmtc/core';
+ *
+ * // With explicit base path
+ * const resolved1 = toResolvedArtifactPath({
+ *   basePath: './src/generated',
+ *   destinationPath: 'models/User.ts'
+ * });
+ * console.log(resolved1); // './src/generated/models/User.ts'
+ *
+ * // With undefined base path (uses default)
+ * const resolved2 = toResolvedArtifactPath({
+ *   basePath: undefined,
+ *   destinationPath: 'types.ts'
+ * });
+ * console.log(resolved2); // './types.ts'
+ * ```
+ *
+ * @example Special path prefix handling
+ * ```typescript
+ * // '@/' prefix gets stripped and resolved relative to base
+ * const resolved = toResolvedArtifactPath({
+ *   basePath: './output',
+ *   destinationPath: '@/api/models.ts'
+ * });
+ * console.log(resolved); // './output/api/models.ts'
+ *
+ * // Regular paths work normally
+ * const normal = toResolvedArtifactPath({
+ *   basePath: './build',
+ *   destinationPath: 'components/Button.tsx'
+ * });
+ * console.log(normal); // './build/components/Button.tsx'
+ * ```
+ *
+ * @example Cross-platform path resolution
+ * ```typescript
+ * // Works consistently across platforms
+ * const windowsPath = toResolvedArtifactPath({
+ *   basePath: 'C:\\projects\\app\\dist',
+ *   destinationPath: 'utils/helpers.js'
+ * });
+ *
+ * const unixPath = toResolvedArtifactPath({
+ *   basePath: '/home/user/projects/app/dist',
+ *   destinationPath: 'utils/helpers.js'
+ * });
+ * ```
+ *
+ * @example Usage in file generation
+ * ```typescript
+ * class ArtifactWriter {
+ *   writeArtifact(
+ *     content: string,
+ *     destination: string,
+ *     baseDir?: string
+ *   ) {
+ *     const resolvedPath = toResolvedArtifactPath({
+ *       basePath: baseDir,
+ *       destinationPath: destination
+ *     });
+ *
+ *     console.log(`Writing to: ${resolvedPath}`);
+ *     return Deno.writeTextFile(resolvedPath, content);
+ *   }
+ * }
+ *
+ * const writer = new ArtifactWriter();
+ * await writer.writeArtifact(
+ *   'export const greeting = "Hello";',
+ *   '@/constants.ts',
+ *   './src/generated'
+ * );
+ * // Writes to: ./src/generated/constants.ts
+ * ```
+ *
+ * @example Integration with rendering pipeline
+ * ```typescript
+ * class FileRenderer {
+ *   renderFiles(
+ *     files: Map<string, File>,
+ *     outputDir: string
+ *   ): Record<string, string> {
+ *     const artifacts: Record<string, string> = {};
+ *
+ *     for (const [destPath, file] of files) {
+ *       const resolvedPath = toResolvedArtifactPath({
+ *         basePath: outputDir,
+ *         destinationPath: destPath
+ *       });
+ *
+ *       artifacts[resolvedPath] = file.toString();
+ *     }
+ *
+ *     return artifacts;
+ *   }
+ * }
+ * ```
+ *
+ * @example Dynamic base path resolution
+ * ```typescript
+ * function resolveForEnvironment(
+ *   destination: string,
+ *   env: 'development' | 'production'
+ * ): string {
+ *   const basePaths = {
+ *     development: './dev-output',
+ *     production: './dist'
+ *   };
+ *
+ *   return toResolvedArtifactPath({
+ *     basePath: basePaths[env],
+ *     destinationPath: destination
+ *   });
+ * }
+ *
+ * const devPath = resolveForEnvironment('api.ts', 'development');
+ * const prodPath = resolveForEnvironment('api.ts', 'production');
+ *
+ * console.log(devPath);  // './dev-output/api.ts'
+ * console.log(prodPath); // './dist/api.ts'
+ * ```
+ */
 const toResolvedArtifactPath = ({ basePath, destinationPath }) => {
     return (0, join_js_1.join)(basePath ?? './', destinationPath.replace(/^@\//, ''));
 };

package/script/oas/schema/Schema.d.ts

@@ -7,8 +7,125 @@ import type { OasObject } from '../object/Object.js';
 import type { OasString } from '../string/String.js';
 import type { OasUnknown } from '../unknown/Unknown.js';
 import type { OasUnion } from '../union/Union.js';
+/**
+ * Union type representing all possible OpenAPI Schema objects in the SKMTC system.
+ *
+ * `OasSchema` is the fundamental type for representing any OpenAPI schema definition
+ * after it has been parsed and processed by the SKMTC pipeline. It encompasses all
+ * JSON Schema types supported by OpenAPI 3.x specifications, providing type-safe
+ * access to schema properties and validation constraints.
+ *
+ * This union type is used throughout the system for schema processing, type generation,
+ * and validation. Each variant corresponds to a specific JSON Schema type with its
+ * own set of properties and validation rules.
+ *
+ * ## Supported Schema Types
+ *
+ * - **{@link OasArray}**: Array schemas with item type definitions and constraints
+ * - **{@link OasBoolean}**: Boolean schemas with optional default values
+ * - **{@link OasInteger}**: Integer schemas with numeric constraints and formats
+ * - **{@link OasNumber}**: Number schemas with numeric constraints and formats
+ * - **{@link OasObject}**: Object schemas with properties, required fields, and constraints
+ * - **{@link OasString}**: String schemas with length constraints, patterns, and formats
+ * - **{@link OasUnknown}**: Schemas with unknown or mixed types
+ * - **{@link OasUnion}**: Union schemas representing oneOf/anyOf/allOf constructs
+ *
+ * @example Type checking and processing
+ * ```typescript
+ * import type { OasSchema } from '@skmtc/core';
+ *
+ * function processSchema(schema: OasSchema): string {
+ *   if (schema.type === 'object') {
+ *     // TypeScript knows this is OasObject
+ *     return `Object with ${Object.keys(schema.properties || {}).length} properties`;
+ *   } else if (schema.type === 'array') {
+ *     // TypeScript knows this is OasArray
+ *     return `Array of ${schema.items.type} items`;
+ *   } else if (schema.type === 'string') {
+ *     // TypeScript knows this is OasString
+ *     return `String${schema.format ? ` (${schema.format})` : ''}`;
+ *   }
+ *   // Handle other types...
+ *   return `${schema.type} type`;
+ * }
+ * ```
+ *
+ * @example Schema validation and constraints
+ * ```typescript
+ * function validateSchemaConstraints(schema: OasSchema, value: unknown): boolean {
+ *   switch (schema.type) {
+ *     case 'string':
+ *       if (typeof value !== 'string') return false;
+ *       if (schema.minLength && value.length < schema.minLength) return false;
+ *       if (schema.maxLength && value.length > schema.maxLength) return false;
+ *       if (schema.pattern && !new RegExp(schema.pattern).test(value)) return false;
+ *       return true;
+ *
+ *     case 'integer':
+ *     case 'number':
+ *       if (typeof value !== 'number') return false;
+ *       if (schema.minimum && value < schema.minimum) return false;
+ *       if (schema.maximum && value > schema.maximum) return false;
+ *       return true;
+ *
+ *     case 'array':
+ *       if (!Array.isArray(value)) return false;
+ *       if (schema.minItems && value.length < schema.minItems) return false;
+ *       if (schema.maxItems && value.length > schema.maxItems) return false;
+ *       return true;
+ *
+ *     default:
+ *       return true;
+ *   }
+ * }
+ * ```
+ *
+ * @example Code generation based on schema type
+ * ```typescript
+ * class TypeScriptGenerator {
+ *   generateType(schema: OasSchema): string {
+ *     switch (schema.type) {
+ *       case 'object':
+ *         return this.generateInterface(schema);
+ *       case 'array':
+ *         return `Array<${this.generateType(schema.items)}>`;
+ *       case 'string':
+ *         if (schema.enums) {
+ *           return schema.enums.map(e => `'${e}'`).join(' | ');
+ *         }
+ *         return 'string';
+ *       case 'integer':
+ *       case 'number':
+ *         return 'number';
+ *       case 'boolean':
+ *         return 'boolean';
+ *       case 'union':
+ *         return schema.variants.map(v => this.generateType(v)).join(' | ');
+ *       default:
+ *         return 'unknown';
+ *     }
+ *   }
+ * }
+ * ```
+ */
 export type OasSchema = OasArray | OasBoolean | OasInteger | OasNumber | OasObject | OasString | OasUnknown | OasUnion;
+/**
+ * Configuration options for JSON Schema conversion operations.
+ *
+ * These options control how OAS schemas are converted back to JSON Schema format,
+ * particularly around reference resolution and schema inlining behavior.
+ *
+ * @example
+ * ```typescript
+ * const options: ToJsonSchemaOptions = {
+ *   resolve: true  // Resolve $ref references during conversion
+ * };
+ *
+ * const jsonSchema = schema.toJsonSchema(options);
+ * ```
+ */
 export type ToJsonSchemaOptions = {
+    /** Whether to resolve $ref references during conversion (default: false) */
     resolve: boolean;
 };
 //# sourceMappingURL=Schema.d.ts.map

package/script/oas/schema/Schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../../../src/oas/schema/Schema.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAEjD,MAAM,MAAM,SAAS,GACjB,QAAQ,GACR,UAAU,GACV,UAAU,GACV,SAAS,GACT,SAAS,GACT,SAAS,GACT,UAAU,GACV,QAAQ,CAAA;AAEZ,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA"}
+{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../../../src/oas/schema/Schema.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoGG;AACH,MAAM,MAAM,SAAS,GACjB,QAAQ,GACR,UAAU,GACV,UAAU,GACV,SAAS,GACT,SAAS,GACT,SAAS,GACT,UAAU,GACV,QAAQ,CAAA;AAEZ;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,4EAA4E;IAC5E,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA"}

package/script/typescript/identifiers.d.ts

@@ -1,3 +1,162 @@
+/**
+ * Safely formats a key for use in object literals, adding quotes if needed.
+ *
+ * This function determines whether a property key needs to be quoted in JavaScript/TypeScript
+ * object literals based on identifier naming rules. Valid identifiers are left unquoted,
+ * while invalid identifiers (containing spaces, special characters, starting with numbers, etc.)
+ * are wrapped in single quotes.
+ *
+ * @param key - The property key to format
+ * @returns The key as-is if it's a valid identifier, otherwise wrapped in quotes
+ *
+ * @example Valid identifiers (no quotes needed)
+ * ```typescript
+ * import { handleKey } from '@skmtc/core';
+ *
+ * console.log(handleKey('name'));      // 'name'
+ * console.log(handleKey('userName'));  // 'userName'
+ * console.log(handleKey('_private'));  // '_private'
+ * console.log(handleKey('$special'));  // '$special'
+ * ```
+ *
+ * @example Invalid identifiers (quotes added)
+ * ```typescript
+ * console.log(handleKey('first-name'));  // "'first-name'"
+ * console.log(handleKey('2nd-place'));   // "'2nd-place'"
+ * console.log(handleKey('user name'));   // "'user name'"
+ * console.log(handleKey('api-key'));     // "'api-key'"
+ * console.log(handleKey('data.nested')); // "'data.nested'"
+ * ```
+ *
+ * @example Usage in object generation
+ * ```typescript
+ * class ObjectGenerator {
+ *   generateObjectLiteral(properties: Record<string, string>) {
+ *     const props = Object.entries(properties)
+ *       .map(([key, value]) => `${handleKey(key)}: ${value}`)
+ *       .join(', ');
+ *
+ *     return `{ ${props} }`;
+ *   }
+ * }
+ *
+ * const generator = new ObjectGenerator();
+ * const result = generator.generateObjectLiteral({
+ *   'name': 'string',
+ *   'first-name': 'string',
+ *   'age': 'number'
+ * });
+ *
+ * console.log(result);
+ * // { name: string, 'first-name': string, age: number }
+ * ```
+ *
+ * @example TypeScript interface generation
+ * ```typescript
+ * function generateInterface(name: string, properties: Record<string, string>) {
+ *   const props = Object.entries(properties)
+ *     .map(([key, type]) => `  ${handleKey(key)}: ${type};`)
+ *     .join('\n');
+ *
+ *   return `interface ${name} {\n${props}\n}`;
+ * }
+ *
+ * const userInterface = generateInterface('User', {
+ *   'id': 'string',
+ *   'first-name': 'string',
+ *   'last_name': 'string',
+ *   '2fa-enabled': 'boolean'
+ * });
+ *
+ * console.log(userInterface);
+ * // interface User {
+ * //   id: string;
+ * //   'first-name': string;
+ * //   last_name: string;
+ * //   '2fa-enabled': boolean;
+ * // }
+ * ```
+ */
 export declare const handleKey: (key: string) => string;
+/**
+ * Safely formats property access, using dot notation or bracket notation as appropriate.
+ *
+ * This function generates the appropriate property access syntax for JavaScript/TypeScript
+ * code. Valid identifiers use dot notation (`parent.property`), while invalid identifiers
+ * use bracket notation (`parent['property']`).
+ *
+ * @param name - The property name to access
+ * @param parent - The parent object expression
+ * @returns Properly formatted property access expression
+ *
+ * @example Valid identifiers (dot notation)
+ * ```typescript
+ * import { handlePropertyName } from '@skmtc/core';
+ *
+ * console.log(handlePropertyName('name', 'user'));      // 'user.name'
+ * console.log(handlePropertyName('firstName', 'user')); // 'user.firstName'
+ * console.log(handlePropertyName('_id', 'document'));   // 'document._id'
+ * console.log(handlePropertyName('$meta', 'data'));     // 'data.$meta'
+ * ```
+ *
+ * @example Invalid identifiers (bracket notation)
+ * ```typescript
+ * console.log(handlePropertyName('first-name', 'user'));  // "user['first-name']"
+ * console.log(handlePropertyName('2nd-place', 'result')); // "result['2nd-place']"
+ * console.log(handlePropertyName('user name', 'form'));   // "form['user name']"
+ * console.log(handlePropertyName('api-key', 'config'));   // "config['api-key']"
+ * ```
+ *
+ * @example Usage in accessor generation
+ * ```typescript
+ * class PropertyAccessor {
+ *   generateGetter(objectName: string, propertyPath: string[]) {
+ *     return propertyPath.reduce((acc, prop) =>
+ *       handlePropertyName(prop, acc), objectName
+ *     );
+ *   }
+ * }
+ *
+ * const accessor = new PropertyAccessor();
+ * const path1 = accessor.generateGetter('data', ['user', 'profile', 'firstName']);
+ * const path2 = accessor.generateGetter('config', ['api-settings', 'retry-count']);
+ *
+ * console.log(path1); // 'data.user.profile.firstName'
+ * console.log(path2); // "config['api-settings']['retry-count']"
+ * ```
+ *
+ * @example Complex object navigation
+ * ```typescript
+ * function generateObjectAccess(base: string, properties: string[]) {
+ *   let result = base;
+ *
+ *   for (const prop of properties) {
+ *     result = handlePropertyName(prop, result);
+ *   }
+ *
+ *   return result;
+ * }
+ *
+ * const access1 = generateObjectAccess('response', ['data', 'user-info', 'name']);
+ * const access2 = generateObjectAccess('settings', ['ui', 'theme', 'darkMode']);
+ *
+ * console.log(access1); // "response.data['user-info'].name"
+ * console.log(access2); // "settings.ui.theme.darkMode"
+ * ```
+ *
+ * @example Function generation
+ * ```typescript
+ * function generatePropertyGetter(objName: string, propName: string) {
+ *   const access = handlePropertyName(propName, objName);
+ *   return `function get${propName.replace(/[^a-zA-Z0-9]/g, '')}() { return ${access}; }`;
+ * }
+ *
+ * const getter1 = generatePropertyGetter('user', 'firstName');
+ * const getter2 = generatePropertyGetter('config', 'api-key');
+ *
+ * console.log(getter1); // "function getfirstName() { return user.firstName; }"
+ * console.log(getter2); // "function getapikey() { return config['api-key']; }"
+ * ```
+ */
 export declare const handlePropertyName: (name: string, parent: string) => string;
 //# sourceMappingURL=identifiers.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"identifiers.d.ts","sourceRoot":"","sources":["../../src/typescript/identifiers.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,KAAG,MAEvC,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,EAAE,QAAQ,MAAM,KAAG,MAEjE,CAAA"}
+{"version":3,"file":"identifiers.d.ts","sourceRoot":"","sources":["../../src/typescript/identifiers.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,KAAG,MAEvC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,EAAE,QAAQ,MAAM,KAAG,MAEjE,CAAA"}