@localazy/cdn-client 1.1.1

package/dist/index.d.ts

@@ -0,0 +1,465 @@
+import { AxiosInstance } from 'axios';
+import { AxiosRequestConfig } from 'axios';
+import { AxiosResponse } from 'axios';
+import { CreateAxiosDefaults } from 'axios';
+
+export declare class Api {
+    protected context: Context;
+    constructor(context: Context);
+    fetchLocale(options: ApiLocaleRequest): Promise<AxiosResponse>;
+    fetchMetafile(config?: AxiosRequestConfig): Promise<AxiosResponse<IMetafile>>;
+}
+
+export declare type ApiLocaleRequest = ILocalesCacheItem;
+
+export declare class AxiosHttpAdapter implements IHttpAdapter {
+    client: AxiosInstance;
+    constructor(baseUrl: string, config?: CreateAxiosDefaults);
+    protected static clientFactory(baseURL: string, config?: CreateAxiosDefaults): AxiosInstance;
+    get<T = unknown, D = unknown>(url: string, config?: AxiosRequestConfig<D>): Promise<T>;
+}
+
+export declare type CacheGetLocalesRequest = ILocalesCacheItem;
+
+export declare type CacheHasLocalesRequest = ILocalesCacheItem;
+
+export declare type CacheKeyMetafileOptions = ILocalesCacheItem;
+
+export declare type CacheStoreLocalesRequest = ILocalesCacheItem & {
+    data: object | string;
+};
+
+export declare abstract class CdnBase {
+    protected context: Context;
+    constructor(context: Context);
+}
+
+export declare class CdnCache extends CdnBase {
+    flush: () => void;
+}
+
+export declare class CdnClient {
+    metafile: CdnMetafile;
+    cache: CdnCache;
+    protected context: Context;
+    protected constructor(options: CdnClientOptions, config?: CreateAxiosDefaults);
+    fetch: (options?: CdnFetchOptions) => Promise<CdnResponse>;
+    static create(options: CdnClientOptions, config?: CreateAxiosDefaults): Promise<CdnClient>;
+}
+
+export declare type CdnClientOptions = {
+    /**
+     * Project metafile URL.
+     */
+    metafile: string;
+};
+
+export declare type CdnFetchOptions = {
+    /**
+     * Select single or multiple files to fetch from the CDN.
+     *
+     * Default: all files in the metafile.
+     */
+    files?: (CdnFile | string)[] | CdnFile | string;
+    /**
+     * Select single or multiple locales to fetch from the CDN.
+     *
+     * Default: all locales in the metafile.
+     */
+    locales?: string[] | string;
+    /**
+     * Exclude the base locale from the list of locales to fetch.
+     */
+    excludeBaseLocale?: boolean;
+};
+
+export declare type CdnFile = {
+    /**
+     * File ID.
+     */
+    id: string;
+    /**
+     * File name.
+     */
+    file: string;
+    /**
+     * File path.
+     */
+    path: string;
+    /**
+     * File library.
+     */
+    library: string;
+    /**
+     * File module.
+     */
+    module: string;
+    /**
+     * File build type.
+     */
+    buildType: string;
+    /**
+     * File product flavors.
+     */
+    productFlavors: string[];
+    /**
+     * File locales.
+     */
+    locales: CdnFileLocale[];
+};
+
+export declare type CdnFileLocale = {
+    /**
+     * Locale code.
+     */
+    locale: string;
+    /**
+     * Boolean indicating if this is the base locale.
+     */
+    isBaseLocale: boolean;
+    /**
+     * File URI.
+     */
+    uri: string;
+};
+
+export declare type CdnFilesSearchOptions = ((file: CdnFile, index?: number, array?: CdnFile[]) => boolean) | {
+    id?: string;
+    file?: string;
+    path?: string;
+    library?: string;
+    module?: string;
+    buildType?: string;
+    productFlavors?: string[];
+};
+
+export declare type CdnLocale = {
+    /**
+     * Locale code.
+     */
+    locale: string;
+    /**
+     * Boolean indicating if this is the base locale.
+     */
+    isBaseLocale: boolean;
+    /**
+     * Language code.
+     */
+    language: string;
+    /**
+     * Region code.
+     */
+    region?: string;
+    /**
+     * Script code.
+     */
+    script?: string;
+    /**
+     * Boolean indicating if the locale is right-to-left.
+     */
+    isRtl: boolean;
+    /**
+     * Locale name.
+     */
+    name: string;
+    /**
+     * Localized locale name.
+     */
+    localizedName: string;
+};
+
+export declare type CdnLocalesOptions = {
+    /**
+     * Exclude the base locale from the list of locales.
+     */
+    excludeBaseLocale?: boolean;
+};
+
+export declare class CdnMetafile extends CdnBase {
+    files: CdnMetafileFiles;
+    constructor(context: Context);
+    get projectUrl(): string;
+    get baseLocale(): CdnLocale;
+    get url(): string;
+    locales: (options?: CdnLocalesOptions) => CdnLocale[];
+    refresh: (config?: AxiosRequestConfig) => Promise<void>;
+    switch: (options: CdnClientOptions, config?: AxiosRequestConfig) => Promise<void>;
+}
+
+export declare class CdnMetafileFiles extends CdnBase {
+    list: () => CdnFile[];
+    filter: (options: CdnFilesSearchOptions) => CdnFile[];
+    find: (options: CdnFilesSearchOptions) => CdnFile | undefined;
+    first: () => CdnFile;
+    protected static transformFiles: (files: MetafileFile[]) => CdnFile[];
+}
+
+export declare type CdnResponse = 
+/**
+* Map of file IDs with locales map as value.
+*/
+    {
+    [fileId: string]: {
+        /**
+         * Map of locales with file content as value.
+         */
+        [locale: string]: object | string;
+    };
+}
+/**
+* Map of locales with file content as value.
+*/
+| {
+    [locale: string]: object | string;
+}
+/**
+* File content.
+*/
+| object
+/**
+* File content as string for non-JSON files.
+*/
+| string;
+
+export declare class Context {
+    metafile: MetafileContext;
+    cdn: CdnClient;
+    client: IHttpAdapter;
+    api: Api;
+    cache: LocalesCache;
+    responseFactory: ResponseFactory;
+    constructor(options: ContextOptions);
+}
+
+export declare type ContextOptions = {
+    metafileContext: MetafileContext;
+    cdn: CdnClient;
+    client: IHttpAdapter;
+};
+
+export declare type ExcludeBaseLocale = {
+    excludeBaseLocale?: boolean;
+};
+
+export declare type FileResponse = {
+    [fileId: string]: LocaleResponse;
+};
+
+export declare type FilesMap = {
+    [id: string]: MetafileFile;
+};
+
+export declare interface ICacheAdapter<K, V> {
+    has: (key: K) => boolean;
+    get: (key: K) => V | undefined;
+    set: (key: K, value: V) => void;
+    flush: () => void;
+}
+
+export declare interface IHttpAdapter {
+    get<T = unknown, D = unknown>(url: string, config?: AxiosRequestConfig<D>): Promise<T>;
+}
+
+export declare interface ILocalesCacheItem {
+    metafileFile: MetafileFile;
+    metafileLocale: MetafileLocale;
+}
+
+export declare interface IMetafile {
+    projectUrl: string;
+    baseLocale: string;
+    timestamp: number;
+    files: IMetafileFiles;
+}
+
+export declare interface IMetafileFile {
+    file: string;
+    path: string;
+    library: string;
+    module: string;
+    buildType: string;
+    timestamp: number;
+    productFlavors: string[];
+    locales: IMetafileFileLocale[];
+}
+
+export declare interface IMetafileFileLocale {
+    language: string;
+    region: string;
+    script: string;
+    isRtl: boolean;
+    name: string;
+    localizedName: string;
+    uri: string;
+    timestamp: number;
+}
+
+export declare interface IMetafileFiles {
+    [id: string]: IMetafileFile;
+}
+
+export declare interface IMetafileParams {
+    url: string;
+    baseUrl: string;
+    cdnId: string;
+    jsonPath: string;
+}
+
+export declare interface IRequestBuilder {
+    addFiles(request?: (CdnFile | string)[] | CdnFile | string): IRequestBuilder;
+    addLocales(request?: string[] | string, excludeBaseLocale?: boolean): IRequestBuilder;
+    getCdnRequest(): Request_2;
+}
+
+export declare type JsonResponse = {
+    [key: string]: Record<string, object>;
+};
+
+export declare type LocaleResponse = {
+    [locale: string]: JsonResponse;
+};
+
+export declare class LocalesCache {
+    protected context: Context;
+    protected cacheAdapter: ICacheAdapter<string, object | string>;
+    constructor(context: Context);
+    setIfMissed(options: CacheStoreLocalesRequest): void;
+    has(options: CacheHasLocalesRequest): boolean;
+    get(options: CacheGetLocalesRequest): object | string | undefined;
+    flush(): void;
+    protected keyFromMetafile(options: CacheKeyMetafileOptions): string;
+}
+
+export declare class LocalesMap {
+    data: LocalesMapData;
+    protected context: Context;
+    constructor(options: LocalesMapOptions);
+}
+
+export declare type LocalesMapData = {
+    [key: string]: MetafileLocale[];
+};
+
+export declare type LocalesMapOptions = {
+    context: Context;
+    data?: LocalesMapData;
+};
+
+export declare class MemoryCacheAdapter<K, V> implements ICacheAdapter<K, V> {
+    protected map: Map<K, V>;
+    constructor();
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): void;
+    flush(): void;
+}
+
+export declare class MetafileContext {
+    params: MetafileParams;
+    parsedData: IMetafile | null;
+    data: MetafileData;
+    constructor(options: CdnClientOptions);
+    setMetafile(metafile: IMetafile): void;
+}
+
+export declare class MetafileData implements Omit<IMetafile, 'files' | 'baseLocale'> {
+    projectUrl: string;
+    baseLocale: CdnLocale;
+    locales: CdnLocale[];
+    timestamp: number;
+    files: MetafileFile[];
+    filesMap: FilesMap;
+    constructor(options: MetafileOptions, params: MetafileParams);
+    static createEmpty(params: MetafileParams): MetafileData;
+    protected static filesFactory(files: IMetafileFiles, baseLocale: string, params: MetafileParams): MetafileFile[];
+    protected static filesMapFactory(files: MetafileFile[]): FilesMap;
+    protected static localesFactory(files: MetafileFile[]): CdnLocale[];
+}
+
+export declare class MetafileFile implements Omit<IMetafileFile, 'locales'> {
+    id: string;
+    file: string;
+    path: string;
+    library: string;
+    module: string;
+    buildType: string;
+    timestamp: number;
+    productFlavors: string[];
+    locales: MetafileLocale[];
+    protected baseUrl: string;
+    constructor(options: MetafileFileOptions);
+    toCdnFile(): CdnFile;
+}
+
+export declare type MetafileFileOptions = Omit<IMetafileFile, 'locales'> & {
+    id: string;
+    locales: MetafileLocale[];
+    baseUrl: string;
+};
+
+export declare class MetafileLocale implements IMetafileFileLocale {
+    language: string;
+    region: string;
+    script: string;
+    isRtl: boolean;
+    name: string;
+    localizedName: string;
+    uri: string;
+    timestamp: number;
+    protected baseLocale: string;
+    constructor(options: IMetafileFileLocale, baseLocale: string);
+    get locale(): string;
+    get isBaseLocale(): boolean;
+    toCdnLocale(): CdnLocale;
+}
+
+export declare type MetafileOptions = IMetafile;
+
+export declare class MetafileParams implements IMetafileParams {
+    protected options: IMetafileParams;
+    constructor(metafileUrl: string);
+    get url(): string;
+    get baseUrl(): string;
+    get cdnId(): string;
+    get jsonPath(): string;
+    protected static parseMetafileUrl(metafileUrl: string): IMetafileParams;
+}
+
+declare class Request_2 {
+    files: MetafileFile[];
+    localesMap: LocalesMap;
+    hasSingleFileResponse: boolean;
+    hasSingleLocaleResponse: boolean;
+    protected context: Context;
+    constructor(context: Context);
+    execute(): Promise<CdnResponse>;
+    protected getPromises(): Promise<AxiosResponse<CdnResponse>>[];
+}
+export { Request_2 as Request }
+
+export declare class RequestBuilder implements IRequestBuilder {
+    protected context: Context;
+    protected request: Request_2;
+    constructor(context: Context);
+    addFiles(files?: (CdnFile | string)[] | CdnFile | string): RequestBuilder;
+    addLocales(locales?: string[] | string, excludeBaseLocale?: boolean): RequestBuilder;
+    getCdnRequest(): Request_2;
+}
+
+export declare class ResponseFactory {
+    protected context: Context;
+    constructor(context: Context);
+    createCdnResponse(options: ResponseFactoryOptions): CdnResponse;
+    protected cacheResponses(responses: AxiosResponse<CdnResponse>[]): void;
+    protected static transformResponsesToOutput(options: ResponseFactoryOptions): CdnResponse;
+    protected static extractReference(response: AxiosResponse<CdnResponse>): Partial<CacheStoreLocalesRequest>;
+}
+
+export declare type ResponseFactoryOptions = {
+    responses: AxiosResponse<CdnResponse>[];
+    localesMap: LocalesMap;
+    hasSingleFileResponse: boolean;
+    hasSingleLocaleResponse: boolean;
+};
+
+export { }