@o3r/localization/builders/helpers/localization.generator.d.ts

This module provides a runtime dynamic language/translation support and debug tools.

import { logging } from '@angular-devkit/core';
import type { LocalizationExtractorBuilderSchema } from '../localization-extractor/schema';
import type { JSONLocalization, LocalizationMetadata } from '@o3r/localization';
/** Map of Localization Metadata base on localization key */
export interface LocalizationMetadataAsMap {
    [key: string]: JSONLocalization;
}
/** Localization structure */
export interface LocalizationJsonValue {
    /** Localization Description */
    description: string;
    /** Determine if the item can have multiple extensions */
    dictionary?: boolean;
    /** Determine if the value has to be overridden */
    referenceData?: boolean;
    /** Localization default value */
    defaultValue?: string;
    /** Tags used for filtering/categorizing */
    tags?: string[];
    /** Reference to other localization */
    $ref?: string;
}
/** Localization file structure */
export interface LocalizationJsonFile {
    [key: string]: LocalizationJsonValue;
}
/** Localization file mapping */
export interface LocalizationFileMap {
    [file: string]: {
        data: LocalizationJsonFile;
        isDependency: boolean;
    };
}
/** Metadata file mapping */
export interface LibraryMetadataMap {
    [libraryMetadataFile: string]: LocalizationMetadata;
}
/**
 * Localization extractor
 */
export declare class LocalizationExtractor {
    private readonly options?;
    /** TsConfig of the file to base on */
    private readonly tsconfigPath;
    private readonly logger;
    constructor(tsconfigPath: string, logger: logging.LoggerApi, options?: Partial<LocalizationExtractorBuilderSchema> | undefined);
    /** Get the list of file from tsconfig.json */
    private getFilesFromTsConfig;
    /**
     * Return the class node if the class is an angular element
     * @param source Ts file source
     */
    private getAngularClassNode;
    /**
     * Get the list of referenced translation files
     * @param localizationFileContent JSON content of a location file
     * @param localizationFilePath Path of the localization file
     */
    private getReferencedFiles;
    /**
     * Read a localization file
     * @param locFile Path to the localization file
     */
    private readLocalizationFile;
    /**
     * Read a metadata file
     * @param metadataFile Path to the metadata file
     */
    private readMetadataFile;
    /**
     * Generate a metadata item from a localization item
     * @param loc Localization item
     * @param key Key of the localization
     */
    private generateMetadataItemFromLocalization;
    /**
     * Compares two JSONLocalization object by their keys and returns the result of the string comparison
     * @param a JSONLocalization
     * @param b JSONLocalization
     */
    private compareKeys;
    /** Get the list of patterns from tsconfig.json */
    getPatternsFromTsConfig(): {
        include: string[];
        exclude: string[];
        cwd: string;
    };
    /**
     * Generate the localization mapping for a list of files
     * @param localizationFiles Localization files to load
     * @param alreadyLoadedFiles List of localization files already loadded
     * @param isDependency Determine if the list of files are dependencies of others
     */
    getLocalizationMap(localizationFiles: string[], alreadyLoadedFiles?: string[], isDependency?: boolean): Promise<LocalizationFileMap>;
    /**
     * Extract the localization mapping from a tsconfig file
     * @param extraLocalizationFiles Additional translations to add
     */
    extractLocalizationFromTsConfig(extraLocalizationFiles?: string[]): Promise<LocalizationFileMap>;
    /**
     * Retrieve metadata from libraries
     * @param libraries Libraries on which the project depend
     */
    getMetadataFromLibraries(libraries: string[]): Promise<LibraryMetadataMap>;
    /**
     * Retrieve metadata from metadata files
     * @param metadataFiles Metadata files
     */
    getMetadataFromFiles(metadataFiles: string[]): Promise<LibraryMetadataMap>;
    /**
     * Generate metadata from localization and library metadata mappings
     * @param localizationMap Map of localization files
     * @param options Option of generation
     * @param options.ignoreDuplicateKeys
     * @param options.libraryMetadata
     * @param options.outputFile
     * @param options.sortKeys
     */
    generateMetadata(localizationMap: LocalizationFileMap, options: {
        ignoreDuplicateKeys: boolean;
        libraryMetadata: LibraryMetadataMap;
        outputFile: string;
        sortKeys: boolean;
    }): LocalizationMetadata;
}
//# sourceMappingURL=localization.generator.d.ts.map