@ngxviewbuilder/runtime 0.12.3 → 0.12.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngxviewbuilder/runtime",
-  "version": "0.12.3",
+  "version": "0.12.4",
   "description": "Native Angular runtime for NGX View Builder: renders forms, dashboards, data tables and guided flows defined as JSON.",
   "license": "SEE LICENSE IN LICENSE.md",
   "homepage": "https://ngxviewbuilder.io",

package/types/ngxviewbuilder-runtime.d.ts

@@ -955,6 +955,87 @@ export interface IDataSourceChangedEvent {
   result: unknown;
   dataSource: DataSourceModel;
 }
+export interface ITranslationEntry {
+  key: string;
+  label: string;
+  sourceValue: string;
+  structurePath?: string;
+}
+/** One translatable text of a view, as `api.getContentTranslationKeys()` lists it. */
+export interface INgxViewBuilderContentTranslationKey {
+  key: string;
+  label: string;
+  /** The text in the view's default language. */
+  source: string;
+  /** What each other language has for it so far. */
+  translations: Record<string, string>;
+  /** The view's other languages that have no text for it yet. */
+  missing: string[];
+}
+export declare class LocalizationService {
+  private templateEngineService;
+  /**
+   * Translations the host supplies through `api.setContentTranslations`, kept apart from
+   * the structure so they survive a view loaded later or replaced. Same shape and keys
+   * as `localization.texts`; on a key both define, the host's text wins.
+   */
+  private hostTexts;
+  /**
+   * The language the host asked for with `api.setLanguage` (or the runtime's `language`
+   * input). It beats the view's own `settings.language`, which is only the default: a view
+   * that arrives after the host picked a language still renders in that language.
+   */
+  private activeLanguage;
+  setActiveLanguage(language: string | null | undefined): void;
+  getActiveLanguage(): string;
+  setHostTexts(texts: Record<string, Record<string, string>>, merge?: boolean): void;
+  getHostTexts(): Record<string, Record<string, string>>;
+  /** The structure's own texts with the host's on top, per language. */
+  getEffectiveTexts(structure: IStructure | null | undefined): Record<string, Record<string, string>>;
+  /**
+   * Keeps translations on the item they belong to when a list is reordered or shortened.
+   * Keys are index paths (`elements.orders.columnsConfig[2].label`), so moving the third
+   * column to the front would otherwise hand its translation to whatever column landed at
+   * index 2. Items match by `id`, then by position when only fields changed, then by
+   * `key`, `value` or `name`. A removed item's translations are dropped.
+   */
+  remapListTranslations(structure: IStructure | null | undefined, listPath: string, previous: unknown, next: unknown): boolean;
+  private matchListItems;
+  ensureLocalization(structure: IStructure | null | undefined): ILocalization;
+  getTranslationEntries(structure: IStructure | null | undefined): ITranslationEntry[];
+  applyTranslations(structure: IStructure): IStructure;
+  /**
+   * Texts an element only has as a default of its model (the two tabs a new tabs element
+   * starts with, a table's empty message) are not in the saved JSON, so `applyTranslations`
+   * had nothing to write their translation into. The translations editor lists them from
+   * the live models, so they are translated here, on the models, once those exist.
+   * `structure` is the one `applyTranslations` returned.
+   */
+  applyTranslationsToModels(structure: IStructure, models: Record<string, unknown> | null | undefined): void;
+  private resolveDictionary;
+  private collectElementEntries;
+  private collectManualListEntries;
+  private collectActionEntries;
+  private collectTableColumnEntries;
+  private collectTemplateDictionaryEntries;
+  private collectStoredTemplateEntries;
+  private collectNestedLocalizableEntries;
+  private collectTemplateTokensFromUnknown;
+  private pushTemplateTranslationEntries;
+  private pushDictionaryEntry;
+  private isLocalizableFieldName;
+  private humanizeFieldName;
+  /**
+   * The built-in strings ship in English only. A view that wants another language
+   * supplies it through its own localization entries, so there is nothing to branch on
+   * here.
+   */
+  private resolveTotalTemplateFallback;
+  private pushStringEntry;
+  private pushStringEntryWithFallback;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LocalizationService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
 export type UiDictionary = Record<string, string>;
 export type UiDictionaries = Record<string, UiDictionary>;
 export declare class UiTranslationService {
@@ -2108,6 +2189,12 @@ export declare class NgxViewBuilderApiService {
   getTableCellElementTypes(): ITableCellElementType[];
   getLanguage(): string;
   setLanguage(language: string): void;
+  /**
+   * A view's own `settings.language` is its default. It is applied only while the host
+   * has not picked a language: otherwise loading a view would switch the host back.
+   */
+  applyViewDefaultLanguage(language: string): void;
+  private applyLanguage;
   resolveHostLanguage(options?: INgxViewBuilderLanguageResolveOptions): INgxViewBuilderResolvedLanguage;
   applyHostLanguage(options?: INgxViewBuilderLanguageResolveOptions): INgxViewBuilderResolvedLanguage;
   startLanguageSync(options?: INgxViewBuilderLanguageSyncOptions): INgxViewBuilderLanguageSyncHandle;
@@ -2151,6 +2238,22 @@ export declare class NgxViewBuilderApiService {
   private applyDefaultDataSourcesTo;
   setAiAssistantConfig(config: INgxViewBuilderAiAssistantConfig | null | undefined): void;
   getAiAssistantConfig(): INgxViewBuilderAiAssistantConfig;
+  /**
+   * Every text of the current view that can be translated: the key to translate it under,
+   * a readable label, the text in the view's default language, and what each language has
+   * for it so far (the view's own translations with the host's on top). `missing` lists the
+   * view's languages that have no text yet.
+   */
+  getContentTranslationKeys(): INgxViewBuilderContentTranslationKey[];
+  /** The view's translations with the host's on top, per language. */
+  getContentTranslations(): Record<string, Record<string, string>>;
+  /**
+   * Content translations from the host, `{ lv: { 'elements.orders.columnsConfig[0].label': 'Vārds' } }`.
+   *
+   * They are kept apart from the view as well as written into it, so they can be supplied
+   * before the view loads and still apply after it is replaced. On a key the view also
+   * translates, the host's text wins. `getContentTranslationKeys()` lists the keys.
+   */
   setContentTranslations(translations: Record<string, Record<string, string>>, merge?: boolean): void;
   requestTabChange(tab: NgxViewBuilderBuilderTabCode): void;
   notifyTabChanged(tab: NgxViewBuilderBuilderTabCode): void;
@@ -2192,7 +2295,14 @@ export declare class NgxViewBuilderApiService {
   replaceSettings(settings: IStructure['settings'] | null | undefined): boolean;
   updateSettings(updater: (settings: IStructure['settings']) => void): boolean;
   setData(data: Record<string, unknown>): void;
-  getData(): Record<string, unknown>;
+  /**
+   * The view's data as the host sees it. The library keeps its own state next to it under
+   * `__` keys (`__variables`, `__route`, `__external`); those are left out unless
+   * `includeInternal` asks for them, e.g. to build an expression context.
+   */
+  getData(options?: {
+    includeInternal?: boolean;
+  }): Record<string, unknown>;
   setTableSettings(identifier: string, settings: INgxViewBuilderTableColumnSetting[], options?: {
     tableName?: string | null;
     elementName?: string | null;
@@ -2232,6 +2342,12 @@ export declare class NgxViewBuilderApiService {
   private readonly inheritedRegistrations;
   private bridgedCallDepth;
   private installScopeBridging;
+  /**
+   * A setting the host changes again (the language every time a person switches it)
+   * would otherwise pile up one replay entry per call. Only its last value matters, and a
+   * full replace of the content translations makes the earlier ones irrelevant too.
+   */
+  private recordInheritedRegistration;
   private invokeBridgedMethod;
   private resolveViewDelegateApi;
   private unregisterScopedChildApi;
@@ -5177,6 +5293,12 @@ export declare class ElementActionService {
   static ɵfac: i0.ɵɵFactoryDeclaration<ElementActionService, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
+/**
+ * Events the API instance already fires on its parent itself (it does that for `<nvb-scope>`,
+ * which has no bridge). Bridging them again made a host subscribed on the root API get each
+ * of them twice.
+ */
+export declare const NGX_VIEW_BUILDER_PARENT_FORWARDED_EVENTS: ReadonlySet<string>;
 /**
  * Forwards every event fired on an isolated (component-provided) API instance to
  * another instance  typically the root singleton the host application injects.
@@ -5748,6 +5870,7 @@ export interface INgxViewBuilderAiSurface {
  */
 export declare class NgxViewBuilderAiApiService {
   private readonly ngxViewBuilderApiService;
+  private readonly localizationService;
   private readonly elementFocusService;
   private readonly eventService;
   private selection;
@@ -6837,6 +6960,12 @@ export declare class ExpressionService {
   private applyPropertyChangeNotification;
   private evaluateAndSet;
   private resolveElementExpressionKey;
+  /**
+   * The element's own state, before any `readonlyIf` / `disableIf`. It is recorded here,
+   * the first time a condition is applied: the preview recorded it lazily, after the first
+   * evaluation had already switched the element off, so the condition's result became the
+   * element's permanent base and the element never came back on.
+   */
   private resolveElementBaseReadonly;
   private resolveElementBaseDisabled;
   private applyResetIfState;
@@ -10250,40 +10379,14 @@ export declare class DomInstrumentationService {
   static ɵfac: i0.ɵɵFactoryDeclaration<DomInstrumentationService, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
-export interface ITranslationEntry {
-  key: string;
-  label: string;
-  sourceValue: string;
-  structurePath?: string;
-}
-export declare class LocalizationService {
-  private templateEngineService;
-  ensureLocalization(structure: IStructure | null | undefined): ILocalization;
-  getTranslationEntries(structure: IStructure | null | undefined): ITranslationEntry[];
-  applyTranslations(structure: IStructure): IStructure;
-  private collectElementEntries;
-  private collectManualListEntries;
-  private collectActionEntries;
-  private collectTableColumnEntries;
-  private collectTemplateDictionaryEntries;
-  private collectStoredTemplateEntries;
-  private collectNestedLocalizableEntries;
-  private collectTemplateTokensFromUnknown;
-  private pushTemplateTranslationEntries;
-  private pushDictionaryEntry;
-  private isLocalizableFieldName;
-  private humanizeFieldName;
-  /**
-   * The built-in strings ship in English only. A view that wants another language
-   * supplies it through its own localization entries, so there is nothing to branch on
-   * here.
-   */
-  private resolveTotalTemplateFallback;
-  private pushStringEntry;
-  private pushStringEntryWithFallback;
-  static ɵfac: i0.ɵɵFactoryDeclaration<LocalizationService, never>;
-  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
-}
+/**
+ * Drops the translations of elements the view no longer has. Content translation keys
+ * start with the element's name, so deleting an element left its rows behind in every
+ * language and the translations table kept listing them.
+ */
+export declare function pruneElementTranslations(localization: ILocalization | null | undefined, elements: Record<string, unknown> | null | undefined): boolean;
+/** Moves an element's translations to its new name when it is renamed. */
+export declare function renameElementTranslations(localization: ILocalization | null | undefined, oldName: string, newName: string): boolean;
 export declare class MarkupSecurityService {
   private sanitizer;
   private documentRef;