@acorex/core 19.13.0-next.5 → 19.13.0-next.8

package/translation/lib/translation.service.d.ts

@@ -1,44 +1,25 @@
+import { AXTranslateLang, AXTranslateOptions } from './translation.types';
 import { Observable } from 'rxjs';
-import { AXTranslateOptions } from './translation.types';
 import * as i0 from "@angular/core";
 export declare function translateSync(key: string, options?: AXTranslateOptions): string;
 export declare class AXTranslationService {
-    private loader;
-    private config;
-    private eventService;
     private localeService;
-    private translationCache;
-    private ongoingRequests;
+    private config;
+    private loader;
+    private parser;
+    private resolver;
     private activeLang;
-    langChanges$: Observable<string>;
-    private expressionCache;
-    getDefaultLang(): string;
-    getActiveLang(): string;
-    setActiveLang(lang: string): void;
-    /**
-     * @ignore
-     */
+    readonly langChanges$: Observable<string>;
     constructor();
-    loadLanguagesAndScopes(languages: string[], scopes: string[]): Observable<unknown>;
-    private fetchTranslationFiles;
-    /**
-     * Set translation data into cache
-     */
-    private setTranslationCache;
-    /**
-     * Get the translation from the cache or fallback to loading
-     */
-    private getTranslationFromCache;
-    isLangAvailable(lang: string, scope?: string): boolean;
-    private translateKey;
-    private isExpression;
-    private decodeExpression;
-    private handleError;
-    private translateText;
+    setActiveLang(lang: AXTranslateLang): void;
+    getActiveLang(): AXTranslateLang;
+    getDefaultLang(): AXTranslateLang;
     translate$(text: string, options?: AXTranslateOptions): Observable<string>;
     translateAsync(text: string, options?: AXTranslateOptions): Promise<string>;
-    translateSync(text: string, options?: AXTranslateOptions): string;
-    private translateTextSync;
+    translateSync(text: string, options?: AXTranslateOptions & {
+        waitForLoad?: boolean;
+        timeoutMs?: number;
+    }): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<AXTranslationService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AXTranslationService>;
 }

package/translation/lib/translation.types.d.ts

@@ -1,10 +1,16 @@
-export type AXTranslateParams<T = unknown> = Record<string, T>;
 export type AXTranslateHashMap<T = unknown> = Record<string, T>;
-export type AXTranslation = Record<string, string>;
 export type AXTranslateLang = string;
 export type AXTranslateScope = string;
+export type AXTranslateParams<T = unknown> = Record<string, T>;
+export type AXTranslation = Record<string, string>;
 export interface AXTranslateOptions {
     lang?: AXTranslateLang;
     scope?: AXTranslateScope;
     params?: AXTranslateParams;
 }
+export interface AXParsedToken {
+    key: string;
+    scope?: AXTranslateScope;
+    lang?: AXTranslateLang;
+    fullMatch: string;
+}

package/translation/lib/translator.pipe.d.ts

@@ -1,11 +1,9 @@
 import { PipeTransform } from '@angular/core';
 import { Observable } from 'rxjs';
-import { AXTranslationService } from './translation.service';
 import { AXTranslateOptions } from './translation.types';
 import * as i0 from "@angular/core";
 export declare class AXTranslatorPipe implements PipeTransform {
     private service;
-    constructor(service: AXTranslationService);
     transform(key: string, options?: AXTranslateOptions): Observable<string>;
     static ɵfac: i0.ɵɵFactoryDeclaration<AXTranslatorPipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<AXTranslatorPipe, "translate", true>;

package/utils/index.d.ts

@@ -1,5 +1,6 @@
-export * from './lib/auto-unsubscribe';
-export * from './lib/color-util';
-export * from './lib/drawing-util';
-export * from './lib/html-util';
-export * from './lib/string-util';
+export * from './lib/lifecycle-helpers.utils';
+export * from './lib/color.utils';
+export * from './lib/drawing.utils';
+export * from './lib/html-utils';
+export * from './lib/string.utils';
+export * from './lib/execution.utils';

package/utils/lib/execution.utils.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Blocks until a condition returns a value or the timeout is reached.
+ * Useful for simulating sync behavior with cached async results.
+ */
+export declare function waitFor<T>(peekFn: () => T | null | undefined, loadFn: () => void, timeoutMs?: number): T | null;
+/**
+ * Delays for a specific amount of time.
+ */
+export declare function delay(ms: number): Promise<void>;
+/**
+ * Retries an async function until it succeeds or a max attempt count is reached.
+ */
+export declare function retryUntil<T>(fn: () => Promise<T>, attempts?: number, delayMs?: number): Promise<T>;
+/**
+ * Continuously polls a condition until it returns true or a timeout is reached.
+ */
+export declare function pollUntil(condition: () => boolean, intervalMs?: number, timeoutMs?: number): Promise<boolean>;
+/**
+ * Throttles an async function to ensure only one instance runs at a time.
+ */
+export declare function throttleAsync<T extends (...args: any[]) => Promise<any>>(fn: T): T;
+/**
+ * Polls a condition with cancel support via AbortSignal.
+ */
+export declare function pollUntilAbortable(condition: () => boolean, intervalMs?: number, timeoutMs?: number, signal?: AbortSignal): Promise<boolean>;
+/**
+ * Debounces an async function to run only after no calls are made within the wait window.
+ */
+export declare function debounceAsync<T extends (...args: any[]) => Promise<any>>(fn: T, waitMs: number): T;
+/**
+ * Runs a list of fallback functions until one resolves without throwing.
+ */
+export declare function fallbackChain<T>(tasks: Array<() => Promise<T>>): Promise<T>;

package/utils/lib/string.utils.d.ts

@@ -0,0 +1,4 @@
+export declare function getWordBoundsAtPosition(str: string, position: number): {
+    start: number;
+    end: number;
+};

package/utils/lib/string-util.d.ts

@@ -1,6 +0,0 @@
-export declare class AXStringUtil {
-    static getWordBoundsAtPosition(str: string, position: number): {
-        start: number;
-        end: number;
-    };
-}