@vocab/core 0.0.0-add-support-for-vocab-cjs-20231109235141

package/LICENSE

@@ -0,0 +1,21 @@
+### MIT License
+
+Copyright (c) 2020 SEEK
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/declarations/src/compile.d.ts

@@ -0,0 +1,6 @@
+import type { LoadedTranslation, UserConfig } from "./types.js";
+export declare function generateRuntime(loadedTranslation: LoadedTranslation): Promise<void>;
+export declare function watch(config: UserConfig): () => Promise<void>;
+export declare function compile({ watch: shouldWatch }: {
+    watch?: boolean | undefined;
+} | undefined, config: UserConfig): Promise<(() => Promise<void>) | undefined>;

package/dist/declarations/src/config.d.ts

@@ -0,0 +1,4 @@
+import type { UserConfig } from "./types.js";
+export declare function validateConfig(c: UserConfig): boolean;
+export declare function resolveConfig(customConfigFilePath?: string): Promise<UserConfig | null>;
+export declare function resolveConfigSync(customConfigFilePath?: string): UserConfig | null;

package/dist/declarations/src/icu-handler.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedICUMessages, TranslationMessagesByKey } from "./types.js";
+export declare const getParsedICUMessages: (m: TranslationMessagesByKey, locale: string) => ParsedICUMessages<any>;

package/dist/declarations/src/index.d.ts

@@ -0,0 +1,6 @@
+export { compile, watch } from "./compile.js";
+export { validate } from "./validate/index.js";
+export { resolveConfig, resolveConfigSync, validateConfig } from "./config.js";
+export { getAltLanguages, getAltLanguageFilePath, getDevLanguageFileFromTsFile, } from "./utils.js";
+export { getUniqueKey, loadAllTranslations, loadTranslation, } from "./load-translations.js";
+export * from "./types.js";

package/dist/declarations/src/load-translations.d.ts

@@ -0,0 +1,32 @@
+import type { TranslationsByKey, UserConfig, LoadedTranslation, LanguageTarget } from "./types.js";
+import { type Fallback } from "./utils.js";
+export declare function getUniqueKey(key: string, namespace: string): string;
+export declare function mergeWithDevLanguageTranslation({ translation, devTranslation, }: {
+    translation: TranslationsByKey;
+    devTranslation: TranslationsByKey;
+}): TranslationsByKey<string>;
+export declare function getLanguageHierarchy({ languages, }: {
+    languages: Array<LanguageTarget>;
+}): Map<string, string[]>;
+export declare function getFallbackLanguageOrder({ languages, languageName, devLanguage, fallbacks, }: {
+    languages: LanguageTarget[];
+    languageName: string;
+    devLanguage: string;
+    fallbacks: Fallback;
+}): string[];
+export declare function loadAltLanguageFile({ filePath, languageName, devTranslation, fallbacks, }: {
+    filePath: string;
+    languageName: string;
+    devTranslation: TranslationsByKey;
+    fallbacks: Fallback;
+}, { devLanguage, languages }: UserConfig): TranslationsByKey;
+export declare function loadTranslation({ filePath, fallbacks, withTags, }: {
+    filePath: string;
+    fallbacks: Fallback;
+    withTags?: boolean;
+}, userConfig: UserConfig): LoadedTranslation;
+export declare function loadAllTranslations({ fallbacks, includeNodeModules, withTags, }: {
+    fallbacks: Fallback;
+    includeNodeModules: boolean;
+    withTags?: boolean;
+}, config: UserConfig): Promise<Array<LoadedTranslation>>;

package/dist/declarations/src/runtime.d.ts

@@ -0,0 +1,3 @@
+import type { TranslationModule, TranslationMessagesByKey } from "./types.js";
+export { createTranslationFile } from "./translation-file.js";
+export declare const createLanguage: (module: TranslationMessagesByKey) => TranslationModule<any>;

package/dist/declarations/src/translation-file.d.ts

@@ -0,0 +1,2 @@
+import type { TranslationModuleByLanguage, LanguageName, ParsedFormatFnByKey, TranslationFile } from "./types.js";
+export declare function createTranslationFile<Language extends LanguageName, FormatFnByKey extends ParsedFormatFnByKey>(translationsByLanguage: TranslationModuleByLanguage<Language, FormatFnByKey>): TranslationFile<Language, FormatFnByKey>;

package/dist/declarations/src/types.d.ts

@@ -0,0 +1,117 @@
+export type { FormatXMLElementFn } from 'intl-messageformat';
+export type LanguageName = string;
+export type TranslationKey = string;
+export type TranslationMessage = string;
+export type ParsedFormatFn = (parts: any) => any;
+export type ParsedFormatFnByKey = Record<string, ParsedFormatFn>;
+/**
+ * Equivalent to the `string` type, but tricks the language server into prodiving
+ * suggestions for string literals passed into the `Suggestions` generic parameter
+ *
+ * @example
+ * Accept any string, but suggest specific animals
+ * ```
+ * type AnyAnimal = StringWithSuggestions<"cat" | "dog">;
+ * // Suggests cat and dog, but accepts any string
+ * const animal: AnyAnimal = "";
+ * ```
+ */
+export type StringWithSuggestions<Suggestions extends string> = Suggestions | Omit<string, Suggestions>;
+/**
+ * ParsedICUMessage A strictly typed formatter from intl-messageformat
+ */
+interface ParsedICUMessage<FormatFn extends ParsedFormatFn> {
+    format: FormatFn;
+}
+export type ParsedICUMessages<FormatFnByKey extends ParsedFormatFnByKey> = {
+    [key in keyof FormatFnByKey]: ParsedICUMessage<FormatFnByKey[key]>;
+};
+/**
+ * TranslationModule is a wrapper around a potentially asynchronously loaded set of ParsedICUMessages
+ */
+export type TranslationModule<FormatFnByKey extends ParsedFormatFnByKey> = {
+    getValue: (locale: string) => ParsedICUMessages<FormatFnByKey> | undefined;
+    load: () => Promise<void>;
+};
+export type TranslationModuleByLanguage<Language extends LanguageName, FormatFnByKey extends ParsedFormatFnByKey> = Record<Language, TranslationModule<FormatFnByKey>>;
+/**
+ * TranslationFile contains a record of TranslationModules per language, exposing a set of methods to load and return the module by language
+ */
+export type TranslationFile<Language extends LanguageName, FormatFnByKey extends ParsedFormatFnByKey> = {
+    /**
+     *  Retrieve messages. If not loaded, will attempt to load messages and resolve once complete.
+     */
+    getMessages: (language: Language, locale?: string) => Promise<ParsedICUMessages<FormatFnByKey>>;
+    /**
+     *  Retrieve already loaded messages. Will return null if no messages have been loaded.
+     */
+    getLoadedMessages: (language: Language, locale?: string) => ParsedICUMessages<FormatFnByKey> | null;
+    /**
+     *  Load messages for the given language. Resolving once complete.
+     */
+    load: (language: Language) => Promise<void>;
+};
+export type TranslationKeys<Translations extends TranslationFile<any, ParsedFormatFnByKey>> = keyof Awaited<ReturnType<Translations['getMessages']>>;
+export interface LanguageTarget {
+    name: LanguageName;
+    extends?: LanguageName;
+}
+export interface MessageGenerator {
+    transformElement?: (element: string) => string;
+    transformMessage?: (message: string) => string;
+}
+export interface GeneratedLanguageTarget {
+    name: LanguageName;
+    extends?: LanguageName;
+    generator: MessageGenerator;
+}
+export interface UserConfig {
+    /**
+     * The root directory to compile and validate translations
+     */
+    projectRoot?: string;
+    /**
+     * The language used in translations.json
+     */
+    devLanguage: LanguageName;
+    /**
+     * An array of languages to build for
+     */
+    languages: Array<LanguageTarget>;
+    /**
+     * An array of languages to generate from existing translations
+     */
+    generatedLanguages?: Array<GeneratedLanguageTarget>;
+    /**
+     * A custom suffix to name vocab translation directories
+     */
+    translationsDirectorySuffix?: string;
+    /**
+     * An array of glob paths to ignore from compilation and validation
+     */
+    ignore?: Array<string>;
+}
+export type Tags = Array<string>;
+export interface TranslationFileMetadata {
+    tags?: Tags;
+}
+export interface TranslationData {
+    message: TranslationMessage;
+    description?: string;
+    tags?: Tags;
+    globalKey?: string;
+}
+export type TranslationsByKey<Key extends TranslationKey = string> = Record<Key, TranslationData>;
+export type TranslationFileContents = TranslationsByKey & {
+    _meta?: TranslationFileMetadata;
+};
+export type TranslationMessagesByKey<Key extends TranslationKey = string> = Record<Key, TranslationMessage>;
+export type TranslationsByLanguage<Key extends TranslationKey = string> = Record<LanguageName, TranslationsByKey<Key>>;
+export type LoadedTranslation<Key extends TranslationKey = string> = {
+    namespace: string;
+    keys: Array<Key>;
+    filePath: string;
+    relativePath: string;
+    languages: TranslationsByLanguage<Key>;
+    metadata: TranslationFileMetadata;
+};

package/dist/declarations/src/utils.d.ts

@@ -0,0 +1,26 @@
+import type { LanguageName, LanguageTarget, TranslationsByKey, TranslationMessagesByKey, UserConfig } from "./types.js";
+export declare const defaultTranslationDirSuffix = ".vocab";
+export declare const devTranslationFileName = "translations.json";
+export type Fallback = 'none' | 'valid' | 'all';
+export declare function isDevLanguageFile(filePath: string): boolean;
+export declare function isAltLanguageFile(filePath: string): boolean;
+export declare function isTranslationDirectory(filePath: string, { translationsDirectorySuffix, }: {
+    translationsDirectorySuffix?: string;
+}): boolean;
+export declare function getTranslationFolderGlob({ translationsDirectorySuffix, }: {
+    translationsDirectorySuffix?: string;
+}): string;
+export declare function getDevTranslationFileGlob({ translationsDirectorySuffix, }: {
+    translationsDirectorySuffix?: string;
+}): string;
+export declare function getAltTranslationFileGlob(config: UserConfig): string;
+export declare function getAltLanguages({ devLanguage, languages, }: {
+    devLanguage: LanguageName;
+    languages: Array<LanguageTarget>;
+}): string[];
+export declare function getDevLanguageFileFromTsFile(tsFilePath: string): string;
+export declare function getDevLanguageFileFromAltLanguageFile(altLanguageFilePath: string): string;
+export declare function getTSFileFromDevLanguageFile(devLanguageFilePath: string): string;
+export declare function getAltLanguageFilePath(devLanguageFilePath: string, language: string): string;
+export declare function mapValues<Key extends string, OriginalValue, ReturnValue>(obj: Record<Key, OriginalValue>, func: (val: OriginalValue) => ReturnValue): TranslationMessagesByKey<Key>;
+export declare function getTranslationMessages<Key extends string>(translations: TranslationsByKey<Key>): TranslationMessagesByKey<Key>;

package/dist/declarations/src/validate/index.d.ts

@@ -0,0 +1,3 @@
+import type { UserConfig, LoadedTranslation, LanguageName } from "../types.js";
+export declare function findMissingKeys(loadedTranslation: LoadedTranslation, devLanguageName: LanguageName, altLanguages: Array<LanguageName>): readonly [boolean, Record<string, string[]>];
+export declare function validate(config: UserConfig): Promise<boolean>;

package/dist/vocab-core.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./declarations/src/index";
+//# sourceMappingURL=vocab-core.cjs.d.ts.map

package/dist/vocab-core.cjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vocab-core.cjs.d.ts","sourceRoot":"","sources":["./declarations/src/index.d.ts"],"names":[],"mappings":"AAAA"}