@h2nguyen/arc42-node-mcp-server 1.0.3 → 2.0.0

package/dist/templates/locales/it/templates.js.map

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

package/dist/templates/locales/language-factory.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Language Factory
+ *
+ * Factory for creating language strategy instances.
+ * Handles code normalization and fallback to English for unknown codes.
+ *
+ * @module templates/locales/language-factory
+ *
+ * S.O.L.I.D Principles:
+ * - SRP (Single Responsibility Principle): Only creates instances, not registration
+ * - DIP (Dependency Inversion Principle): Depends on LanguageRegistry abstraction
+ *
+ * Design Patterns:
+ * - Factory Pattern: Centralized object creation
+ */
+import type { LanguageStrategy, LanguageCode } from './language-strategy.js';
+import type { LanguageRegistry } from './language-registry.js';
+/**
+ * Language Factory Class
+ *
+ * Creates language strategy instances from the registry with code normalization
+ * and optional fallback to English for unknown language codes.
+ *
+ * @example
+ * ```typescript
+ * const factory = new LanguageFactory(registry);
+ *
+ * // Strict mode - throws for unknown codes
+ * const german = factory.create('de'); // Case-insensitive
+ *
+ * // Lenient mode - falls back to English
+ * const fallback = factory.createWithFallback('unknown');
+ * ```
+ */
+export declare class LanguageFactory {
+    /**
+     * The registry to retrieve strategies from
+     */
+    private readonly registry;
+    /**
+     * Create a new LanguageFactory
+     *
+     * @param registry - The language registry to use for lookups
+     */
+    constructor(registry: LanguageRegistry);
+    /**
+     * Normalize a language code
+     *
+     * Converts to uppercase and trims whitespace for consistent handling.
+     *
+     * @param code - The language code to normalize
+     * @returns The normalized code (uppercase, trimmed)
+     */
+    normalizeCode(code: string): string;
+    /**
+     * Create a language strategy for the given code
+     *
+     * Performs case-insensitive lookup and throws if the language is not registered.
+     *
+     * @param code - The language code
+     * @returns The language strategy
+     * @throws Error if the language code is not registered
+     */
+    create(code: string): LanguageStrategy;
+    /**
+     * Create a language strategy with fallback to English
+     *
+     * Attempts to create a strategy for the given code. If the code is not registered,
+     * logs a warning and returns the English strategy as fallback.
+     *
+     * @param code - The language code
+     * @returns The language strategy (or English if code not found)
+     * @throws Error if neither the requested code nor English is registered
+     */
+    createWithFallback(code: string): LanguageStrategy;
+    /**
+     * Check if a language code is supported
+     *
+     * @param code - The language code to check
+     * @returns True if the language is registered
+     */
+    isSupported(code: string): boolean;
+    /**
+     * Get all available language codes
+     *
+     * @returns Array of registered language codes
+     */
+    getAvailableCodes(): LanguageCode[];
+    /**
+     * Get the default language strategy (English)
+     *
+     * @returns The English language strategy
+     * @throws Error if English is not registered
+     */
+    getDefault(): LanguageStrategy;
+}
+//# sourceMappingURL=language-factory.d.ts.map

package/dist/templates/locales/language-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-factory.d.ts","sourceRoot":"","sources":["../../../src/templates/locales/language-factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,eAAe;IAC1B;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAE5C;;;;OAIG;gBACS,QAAQ,EAAE,gBAAgB;IAItC;;;;;;;OAOG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAInC;;;;;;;;OAQG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB;IAItC;;;;;;;;;OASG;IACH,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB;IAwBlD;;;;;OAKG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIlC;;;;OAIG;IACH,iBAAiB,IAAI,YAAY,EAAE;IAInC;;;;;OAKG;IACH,UAAU,IAAI,gBAAgB;CAU/B"}

package/dist/templates/locales/language-factory.js

@@ -0,0 +1,126 @@
+/**
+ * Language Factory
+ *
+ * Factory for creating language strategy instances.
+ * Handles code normalization and fallback to English for unknown codes.
+ *
+ * @module templates/locales/language-factory
+ *
+ * S.O.L.I.D Principles:
+ * - SRP (Single Responsibility Principle): Only creates instances, not registration
+ * - DIP (Dependency Inversion Principle): Depends on LanguageRegistry abstraction
+ *
+ * Design Patterns:
+ * - Factory Pattern: Centralized object creation
+ */
+/**
+ * Language Factory Class
+ *
+ * Creates language strategy instances from the registry with code normalization
+ * and optional fallback to English for unknown language codes.
+ *
+ * @example
+ * ```typescript
+ * const factory = new LanguageFactory(registry);
+ *
+ * // Strict mode - throws for unknown codes
+ * const german = factory.create('de'); // Case-insensitive
+ *
+ * // Lenient mode - falls back to English
+ * const fallback = factory.createWithFallback('unknown');
+ * ```
+ */
+export class LanguageFactory {
+    /**
+     * The registry to retrieve strategies from
+     */
+    registry;
+    /**
+     * Create a new LanguageFactory
+     *
+     * @param registry - The language registry to use for lookups
+     */
+    constructor(registry) {
+        this.registry = registry;
+    }
+    /**
+     * Normalize a language code
+     *
+     * Converts to uppercase and trims whitespace for consistent handling.
+     *
+     * @param code - The language code to normalize
+     * @returns The normalized code (uppercase, trimmed)
+     */
+    normalizeCode(code) {
+        return code.trim().toUpperCase();
+    }
+    /**
+     * Create a language strategy for the given code
+     *
+     * Performs case-insensitive lookup and throws if the language is not registered.
+     *
+     * @param code - The language code
+     * @returns The language strategy
+     * @throws Error if the language code is not registered
+     */
+    create(code) {
+        return this.registry.getOrThrow(code);
+    }
+    /**
+     * Create a language strategy with fallback to English
+     *
+     * Attempts to create a strategy for the given code. If the code is not registered,
+     * logs a warning and returns the English strategy as fallback.
+     *
+     * @param code - The language code
+     * @returns The language strategy (or English if code not found)
+     * @throws Error if neither the requested code nor English is registered
+     */
+    createWithFallback(code) {
+        const normalizedCode = this.normalizeCode(code);
+        const strategy = this.registry.get(normalizedCode);
+        if (strategy) {
+            return strategy;
+        }
+        // Log warning and fall back to English
+        console.warn(`Language code "${normalizedCode}" is not registered. Falling back to English.`);
+        const englishStrategy = this.registry.get('EN');
+        if (!englishStrategy) {
+            throw new Error(`Cannot fall back to English: English language is not registered. ` +
+                `Available languages: ${this.registry.getAvailableCodes().join(', ') || 'none'}`);
+        }
+        return englishStrategy;
+    }
+    /**
+     * Check if a language code is supported
+     *
+     * @param code - The language code to check
+     * @returns True if the language is registered
+     */
+    isSupported(code) {
+        return this.registry.isSupported(code);
+    }
+    /**
+     * Get all available language codes
+     *
+     * @returns Array of registered language codes
+     */
+    getAvailableCodes() {
+        return this.registry.getAvailableCodes();
+    }
+    /**
+     * Get the default language strategy (English)
+     *
+     * @returns The English language strategy
+     * @throws Error if English is not registered
+     */
+    getDefault() {
+        const defaultStrategy = this.registry.getDefault();
+        if (!defaultStrategy) {
+            throw new Error('Default language (English) is not registered. ' +
+                `Available languages: ${this.registry.getAvailableCodes().join(', ') || 'none'}`);
+        }
+        return defaultStrategy;
+    }
+}
+//# sourceMappingURL=language-factory.js.map

package/dist/templates/locales/language-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-factory.js","sourceRoot":"","sources":["../../../src/templates/locales/language-factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,eAAe;IAC1B;;OAEG;IACc,QAAQ,CAAmB;IAE5C;;;;OAIG;IACH,YAAY,QAA0B;QACpC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;;;;;;OAOG;IACH,aAAa,CAAC,IAAY;QACxB,OAAO,IAAI,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IACnC,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,IAAY;QACjB,OAAO,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC;IAED;;;;;;;;;OASG;IACH,kBAAkB,CAAC,IAAY;QAC7B,MAAM,cAAc,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QAChD,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QAEnD,IAAI,QAAQ,EAAE,CAAC;YACb,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED,uCAAuC;QACvC,OAAO,CAAC,IAAI,CACV,kBAAkB,cAAc,+CAA+C,CAChF,CAAC;QAEF,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAChD,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CACb,mEAAmE;gBACnE,wBAAwB,IAAI,CAAC,QAAQ,CAAC,iBAAiB,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,MAAM,EAAE,CACjF,CAAC;QACJ,CAAC;QAED,OAAO,eAAe,CAAC;IACzB,CAAC;IAED;;;;;OAKG;IACH,WAAW,CAAC,IAAY;QACtB,OAAO,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IAED;;;;OAIG;IACH,iBAAiB;QACf,OAAO,IAAI,CAAC,QAAQ,CAAC,iBAAiB,EAAE,CAAC;IAC3C,CAAC;IAED;;;;;OAKG;IACH,UAAU;QACR,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC;QACnD,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CACb,gDAAgD;gBAChD,wBAAwB,IAAI,CAAC,QAAQ,CAAC,iBAAiB,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,MAAM,EAAE,CACjF,CAAC;QACJ,CAAC;QACD,OAAO,eAAe,CAAC;IACzB,CAAC;CACF"}

package/dist/templates/locales/language-registry.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Language Registry
+ *
+ * Registry for storing and retrieving language strategies.
+ * Uses Map for O(1) lookup by normalized language code.
+ *
+ * @module templates/locales/language-registry
+ *
+ * S.O.L.I.D Principles:
+ * - SRP (Single Responsibility Principle): Only manages registration and lookup,
+ *   not creation or template retrieval
+ *
+ * Design Patterns:
+ * - Registry Pattern: Single source of truth for language strategies
+ */
+import type { LanguageStrategy, LanguageCode } from './language-strategy.js';
+/**
+ * Language Registry Class
+ *
+ * Manages the collection of language strategies, providing registration,
+ * lookup, and enumeration capabilities with case-insensitive code handling.
+ *
+ * @example
+ * ```typescript
+ * const registry = new LanguageRegistry();
+ * registry.register(englishStrategy);
+ * registry.register(germanStrategy);
+ *
+ * const strategy = registry.get('de'); // Case-insensitive
+ * const allCodes = registry.getAvailableCodes(); // ['EN', 'DE']
+ * ```
+ */
+export declare class LanguageRegistry {
+    /**
+     * Internal map storing strategies by normalized (uppercase) language code
+     */
+    private readonly strategies;
+    constructor();
+    /**
+     * Normalize a language code for consistent storage and lookup
+     *
+     * @param code - The language code to normalize
+     * @returns Uppercase, trimmed language code
+     */
+    private normalizeCode;
+    /**
+     * Register a language strategy
+     *
+     * Stores the strategy using its code (normalized to uppercase).
+     * If a strategy with the same code already exists, it will be overwritten.
+     *
+     * @param strategy - The language strategy to register
+     * @returns This registry instance for method chaining
+     */
+    register(strategy: LanguageStrategy): this;
+    /**
+     * Get a language strategy by code
+     *
+     * Performs case-insensitive lookup.
+     *
+     * @param code - The language code to look up
+     * @returns The language strategy, or undefined if not found
+     */
+    get(code: string): LanguageStrategy | undefined;
+    /**
+     * Get a language strategy by code, throwing if not found
+     *
+     * Performs case-insensitive lookup and throws a descriptive error
+     * if the requested language is not registered.
+     *
+     * @param code - The language code to look up
+     * @returns The language strategy
+     * @throws Error if the language code is not registered
+     */
+    getOrThrow(code: string): LanguageStrategy;
+    /**
+     * Get all registered language strategies
+     *
+     * @returns Array of all registered strategies (copy, not the internal collection)
+     */
+    getAll(): LanguageStrategy[];
+    /**
+     * Check if a language code is supported
+     *
+     * Performs case-insensitive check.
+     *
+     * @param code - The language code to check
+     * @returns True if the language is registered
+     */
+    isSupported(code: string): boolean;
+    /**
+     * Get all available language codes
+     *
+     * @returns Array of all registered language codes (uppercase)
+     */
+    getAvailableCodes(): LanguageCode[];
+    /**
+     * Get the default language strategy (English)
+     *
+     * @returns The English language strategy, or undefined if not registered
+     */
+    getDefault(): LanguageStrategy | undefined;
+    /**
+     * Get the number of registered strategies
+     */
+    get size(): number;
+    /**
+     * Remove all registered strategies
+     *
+     * @returns This registry instance for method chaining
+     */
+    clear(): this;
+}
+//# sourceMappingURL=language-registry.d.ts.map

package/dist/templates/locales/language-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-registry.d.ts","sourceRoot":"","sources":["../../../src/templates/locales/language-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE7E;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,gBAAgB;IAC3B;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgC;;IAM3D;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAIrB;;;;;;;;OAQG;IACH,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI;IAM1C;;;;;;;OAOG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAK/C;;;;;;;;;OASG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB;IAY1C;;;;OAIG;IACH,MAAM,IAAI,gBAAgB,EAAE;IAI5B;;;;;;;OAOG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAKlC;;;;OAIG;IACH,iBAAiB,IAAI,YAAY,EAAE;IAInC;;;;OAIG;IACH,UAAU,IAAI,gBAAgB,GAAG,SAAS;IAI1C;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;OAIG;IACH,KAAK,IAAI,IAAI;CAId"}

package/dist/templates/locales/language-registry.js

@@ -0,0 +1,146 @@
+/**
+ * Language Registry
+ *
+ * Registry for storing and retrieving language strategies.
+ * Uses Map for O(1) lookup by normalized language code.
+ *
+ * @module templates/locales/language-registry
+ *
+ * S.O.L.I.D Principles:
+ * - SRP (Single Responsibility Principle): Only manages registration and lookup,
+ *   not creation or template retrieval
+ *
+ * Design Patterns:
+ * - Registry Pattern: Single source of truth for language strategies
+ */
+/**
+ * Language Registry Class
+ *
+ * Manages the collection of language strategies, providing registration,
+ * lookup, and enumeration capabilities with case-insensitive code handling.
+ *
+ * @example
+ * ```typescript
+ * const registry = new LanguageRegistry();
+ * registry.register(englishStrategy);
+ * registry.register(germanStrategy);
+ *
+ * const strategy = registry.get('de'); // Case-insensitive
+ * const allCodes = registry.getAvailableCodes(); // ['EN', 'DE']
+ * ```
+ */
+export class LanguageRegistry {
+    /**
+     * Internal map storing strategies by normalized (uppercase) language code
+     */
+    strategies;
+    constructor() {
+        this.strategies = new Map();
+    }
+    /**
+     * Normalize a language code for consistent storage and lookup
+     *
+     * @param code - The language code to normalize
+     * @returns Uppercase, trimmed language code
+     */
+    normalizeCode(code) {
+        return code.trim().toUpperCase();
+    }
+    /**
+     * Register a language strategy
+     *
+     * Stores the strategy using its code (normalized to uppercase).
+     * If a strategy with the same code already exists, it will be overwritten.
+     *
+     * @param strategy - The language strategy to register
+     * @returns This registry instance for method chaining
+     */
+    register(strategy) {
+        const normalizedCode = this.normalizeCode(strategy.code);
+        this.strategies.set(normalizedCode, strategy);
+        return this;
+    }
+    /**
+     * Get a language strategy by code
+     *
+     * Performs case-insensitive lookup.
+     *
+     * @param code - The language code to look up
+     * @returns The language strategy, or undefined if not found
+     */
+    get(code) {
+        const normalizedCode = this.normalizeCode(code);
+        return this.strategies.get(normalizedCode);
+    }
+    /**
+     * Get a language strategy by code, throwing if not found
+     *
+     * Performs case-insensitive lookup and throws a descriptive error
+     * if the requested language is not registered.
+     *
+     * @param code - The language code to look up
+     * @returns The language strategy
+     * @throws Error if the language code is not registered
+     */
+    getOrThrow(code) {
+        const strategy = this.get(code);
+        if (!strategy) {
+            const availableCodes = this.getAvailableCodes().join(', ');
+            throw new Error(`Language code "${code.trim().toUpperCase()}" is not registered. ` +
+                `Available languages: ${availableCodes || 'none'}`);
+        }
+        return strategy;
+    }
+    /**
+     * Get all registered language strategies
+     *
+     * @returns Array of all registered strategies (copy, not the internal collection)
+     */
+    getAll() {
+        return Array.from(this.strategies.values());
+    }
+    /**
+     * Check if a language code is supported
+     *
+     * Performs case-insensitive check.
+     *
+     * @param code - The language code to check
+     * @returns True if the language is registered
+     */
+    isSupported(code) {
+        const normalizedCode = this.normalizeCode(code);
+        return this.strategies.has(normalizedCode);
+    }
+    /**
+     * Get all available language codes
+     *
+     * @returns Array of all registered language codes (uppercase)
+     */
+    getAvailableCodes() {
+        return Array.from(this.strategies.keys());
+    }
+    /**
+     * Get the default language strategy (English)
+     *
+     * @returns The English language strategy, or undefined if not registered
+     */
+    getDefault() {
+        return this.get('EN');
+    }
+    /**
+     * Get the number of registered strategies
+     */
+    get size() {
+        return this.strategies.size;
+    }
+    /**
+     * Remove all registered strategies
+     *
+     * @returns This registry instance for method chaining
+     */
+    clear() {
+        this.strategies.clear();
+        return this;
+    }
+}
+//# sourceMappingURL=language-registry.js.map

package/dist/templates/locales/language-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-registry.js","sourceRoot":"","sources":["../../../src/templates/locales/language-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,gBAAgB;IAC3B;;OAEG;IACc,UAAU,CAAgC;IAE3D;QACE,IAAI,CAAC,UAAU,GAAG,IAAI,GAAG,EAAE,CAAC;IAC9B,CAAC;IAED;;;;;OAKG;IACK,aAAa,CAAC,IAAY;QAChC,OAAO,IAAI,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IACnC,CAAC;IAED;;;;;;;;OAQG;IACH,QAAQ,CAAC,QAA0B;QACjC,MAAM,cAAc,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACzD,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;QAC9C,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;OAOG;IACH,GAAG,CAAC,IAAY;QACd,MAAM,cAAc,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QAChD,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;;;;;OASG;IACH,UAAU,CAAC,IAAY;QACrB,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC3D,MAAM,IAAI,KAAK,CACb,kBAAkB,IAAI,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,uBAAuB;gBAClE,wBAAwB,cAAc,IAAI,MAAM,EAAE,CACnD,CAAC;QACJ,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;;OAIG;IACH,MAAM;QACJ,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;;;OAOG;IACH,WAAW,CAAC,IAAY;QACtB,MAAM,cAAc,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QAChD,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IAC7C,CAAC;IAED;;;;OAIG;IACH,iBAAiB;QACf,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAmB,CAAC;IAC9D,CAAC;IAED;;;;OAIG;IACH,UAAU;QACR,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;IAC9B,CAAC;IAED;;;;OAIG;IACH,KAAK;QACH,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;CACF"}

package/dist/templates/locales/language-strategy.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Language Strategy Interface
+ *
+ * Defines the contract for all language implementations in the multi-language template system.
+ * This interface follows the Strategy Pattern, allowing different language implementations
+ * to be used interchangeably.
+ *
+ * @module templates/locales/language-strategy
+ *
+ * S.O.L.I.D Principles:
+ * - ISP (Interface Segregation Principle): Interface is focused only on language content,
+ *   not registration or creation logic
+ * - OCP (Open/Closed Principle): New languages can be added by implementing this interface
+ *   without modifying existing code
+ */
+import type { Arc42Section } from '../../types.js';
+/**
+ * Supported language codes
+ * Based on the arc42 template repository structure
+ */
+export type LanguageCode = 'EN' | 'DE' | 'CZ' | 'ES' | 'FR' | 'IT' | 'NL' | 'PT' | 'RU' | 'UKR' | 'ZH';
+/**
+ * Array of all supported language codes
+ */
+export declare const SUPPORTED_LANGUAGE_CODES: readonly LanguageCode[];
+/**
+ * Section title with associated section identifier
+ */
+export interface SectionTitle {
+    /** The localized title of the section */
+    title: string;
+    /** The section identifier */
+    section: Arc42Section;
+}
+/**
+ * Section description with associated section identifier
+ */
+export interface SectionDescription {
+    /** The localized description of the section */
+    description: string;
+    /** The section identifier */
+    section: Arc42Section;
+}
+/**
+ * Language metadata for display purposes
+ */
+export interface LanguageInfo {
+    /** ISO language code (uppercase) */
+    code: LanguageCode;
+    /** English name of the language */
+    name: string;
+    /** Name of the language in its native form */
+    nativeName: string;
+}
+/**
+ * Language Strategy Interface
+ *
+ * Defines the contract that all language implementations must follow.
+ * Each language strategy provides localized content for arc42 documentation.
+ *
+ * @example
+ * ```typescript
+ * const englishStrategy: LanguageStrategy = {
+ *   code: 'EN',
+ *   name: 'English',
+ *   nativeName: 'English',
+ *   getSectionTitle: (section) => ({ title: 'Introduction and Goals', section }),
+ *   getSectionDescription: (section) => ({ description: 'Overview of requirements...', section }),
+ *   getTemplate: (section) => '# Introduction and Goals\n\n...',
+ *   getWorkflowGuide: () => '# arc42 Workflow Guide\n\n...',
+ *   getReadmeContent: () => '# Project Documentation\n\n...'
+ * };
+ * ```
+ */
+export interface LanguageStrategy extends LanguageInfo {
+    /**
+     * Get the localized title for a specific section
+     *
+     * @param section - The arc42 section identifier
+     * @returns The section title with metadata
+     */
+    getSectionTitle(section: Arc42Section): SectionTitle;
+    /**
+     * Get the localized description for a specific section
+     *
+     * @param section - The arc42 section identifier
+     * @returns The section description with metadata
+     */
+    getSectionDescription(section: Arc42Section): SectionDescription;
+    /**
+     * Get the localized template content for a specific section
+     *
+     * @param section - The arc42 section identifier
+     * @returns The full markdown template for the section
+     */
+    getTemplate(section: Arc42Section): string;
+    /**
+     * Get the localized workflow guide
+     *
+     * @returns The complete workflow guide in markdown format
+     */
+    getWorkflowGuide(): string;
+    /**
+     * Get the localized README content
+     *
+     * @param projectName - Optional project name for README header
+     * @returns The README content in markdown format
+     */
+    getReadmeContent(projectName?: string): string;
+}
+/**
+ * Type guard to check if a value is a valid LanguageCode
+ *
+ * @param value - The value to check
+ * @returns True if the value is a valid LanguageCode
+ */
+export declare function isLanguageCode(value: unknown): value is LanguageCode;
+/**
+ * Normalize a language code to uppercase
+ *
+ * @param code - The language code to normalize
+ * @returns The normalized uppercase language code
+ * @throws Error if the code is not a valid language code
+ */
+export declare function normalizeLanguageCode(code: string): LanguageCode;
+//# sourceMappingURL=language-strategy.d.ts.map

package/dist/templates/locales/language-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-strategy.d.ts","sourceRoot":"","sources":["../../../src/templates/locales/language-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;;GAGG;AACH,MAAM,MAAM,YAAY,GACpB,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,KAAK,GACL,IAAI,CAAC;AAET;;GAEG;AACH,eAAO,MAAM,wBAAwB,EAAE,SAAS,YAAY,EAElD,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,6BAA6B;IAC7B,OAAO,EAAE,YAAY,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,+CAA+C;IAC/C,WAAW,EAAE,MAAM,CAAC;IACpB,6BAA6B;IAC7B,OAAO,EAAE,YAAY,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,oCAAoC;IACpC,IAAI,EAAE,YAAY,CAAC;IACnB,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACpD;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,YAAY,CAAC;IAErD;;;;;OAKG;IACH,qBAAqB,CAAC,OAAO,EAAE,YAAY,GAAG,kBAAkB,CAAC;IAEjE;;;;;OAKG;IACH,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAAC;IAE3C;;;;OAIG;IACH,gBAAgB,IAAI,MAAM,CAAC;IAE3B;;;;;OAKG;IACH,gBAAgB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAChD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAKpE;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAQhE"}

package/dist/templates/locales/language-strategy.js

@@ -0,0 +1,46 @@
+/**
+ * Language Strategy Interface
+ *
+ * Defines the contract for all language implementations in the multi-language template system.
+ * This interface follows the Strategy Pattern, allowing different language implementations
+ * to be used interchangeably.
+ *
+ * @module templates/locales/language-strategy
+ *
+ * S.O.L.I.D Principles:
+ * - ISP (Interface Segregation Principle): Interface is focused only on language content,
+ *   not registration or creation logic
+ * - OCP (Open/Closed Principle): New languages can be added by implementing this interface
+ *   without modifying existing code
+ */
+/**
+ * Array of all supported language codes
+ */
+export const SUPPORTED_LANGUAGE_CODES = [
+    'EN', 'DE', 'CZ', 'ES', 'FR', 'IT', 'NL', 'PT', 'RU', 'UKR', 'ZH'
+];
+/**
+ * Type guard to check if a value is a valid LanguageCode
+ *
+ * @param value - The value to check
+ * @returns True if the value is a valid LanguageCode
+ */
+export function isLanguageCode(value) {
+    return (typeof value === 'string' &&
+        SUPPORTED_LANGUAGE_CODES.includes(value.toUpperCase()));
+}
+/**
+ * Normalize a language code to uppercase
+ *
+ * @param code - The language code to normalize
+ * @returns The normalized uppercase language code
+ * @throws Error if the code is not a valid language code
+ */
+export function normalizeLanguageCode(code) {
+    const normalized = code.trim().toUpperCase();
+    if (!isLanguageCode(normalized)) {
+        throw new Error(`Invalid language code: "${code}". Supported codes: ${SUPPORTED_LANGUAGE_CODES.join(', ')}`);
+    }
+    return normalized;
+}
+//# sourceMappingURL=language-strategy.js.map