@arsedizioni/ars-utils 22.1.5 → 22.5.2

package/types/arsedizioni-ars-utils-ui.notifications.d.ts

@@ -0,0 +1,73 @@
+import * as _angular_core from '@angular/core';
+import { MatPaginator, PageEvent } from '@angular/material/paginator';
+import { ScreenService, SelectableModel } from '@arsedizioni/ars-utils/core';
+import { SupportNotificationInfo, SupportNotificationsSearchParams } from '@arsedizioni/ars-utils/support.common';
+
+declare class SupportNotificationsBrowserComponent {
+    readonly paginator: _angular_core.Signal<MatPaginator>;
+    protected readonly screenService: ScreenService;
+    private readonly supportService;
+    private readonly broadcastService;
+    private readonly dialogService;
+    private readonly destroyRef;
+    protected selection: SelectableModel<SupportNotificationInfo, number>;
+    protected searchParams: SupportNotificationsSearchParams;
+    protected total: _angular_core.WritableSignal<number>;
+    protected items: _angular_core.WritableSignal<SupportNotificationInfo[]>;
+    constructor();
+    /**
+     * Scrolls the notifications list back to the top.
+     */
+    private updateScroll;
+    /**
+     * Resets the `isMenuOpen` flag on all items after a context menu is closed.
+     */
+    protected updateMenuButtonsVisibility(): void;
+    /**
+     * Returns the ids of the currently selected items.
+     * Shows an error and returns `undefined` when the selection exceeds 50 items.
+     * @returns An array of selected notification ids, or `undefined` on validation failure.
+     */
+    private getSelectedIds;
+    /**
+     * Returns the CSS class to apply to the read-state indicator stripe.
+     * @param item - The notification to evaluate.
+     * @returns `'unread-bg'` when the notification has not been read, otherwise `undefined`.
+     */
+    protected getItemStateCssClass(item: SupportNotificationInfo): string | undefined;
+    /**
+     * Returns the tooltip text for the read-state indicator stripe.
+     * @param item - The notification to evaluate.
+     * @returns `'Non letto'` when unread, otherwise an empty string.
+     */
+    protected getItemStateTooltip(item: SupportNotificationInfo): string;
+    /**
+     * Resets pagination to page 0 and fetches a fresh result set.
+     */
+    protected find(): void;
+    /**
+     * Fetches the current page of notifications from the server.
+     */
+    private fetch;
+    /**
+     * Handles paginator page changes and loads the corresponding result page.
+     * @param e - The `PageEvent` emitted by `MatPaginator`.
+     */
+    protected fetchMore(e: PageEvent): void;
+    /**
+     * Marks one or more notifications as read or unread.
+     * When no specific item is supplied, acts on the current selection.
+     * @param item   - A single notification to mark, or `undefined` to use the selection.
+     * @param unmark - `true` to mark as unread; `false` (default) to mark as read.
+     */
+    protected mark(item?: SupportNotificationInfo, unmark?: boolean): void;
+    /**
+     * Opens the notification detail dialog for the given item.
+     * @param item - The notification to display.
+     */
+    protected show(item: SupportNotificationInfo): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SupportNotificationsBrowserComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SupportNotificationsBrowserComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+export { SupportNotificationsBrowserComponent };

package/types/arsedizioni-ars-utils-ui.paginator.d.ts

@@ -0,0 +1,23 @@
+import { MatPaginatorIntl } from '@angular/material/paginator';
+import * as i0 from '@angular/core';
+
+/** Italian localisation for the Material paginator labels. */
+declare class PaginatorIntl extends MatPaginatorIntl {
+    itemsPerPageLabel: string;
+    nextPageLabel: string;
+    previousPageLabel: string;
+    lastPageLabel: string;
+    firstPageLabel: string;
+    /**
+     * Returns the human-readable range label shown inside the paginator.
+     * @param page     - Zero-based index of the current page.
+     * @param pageSize - Number of items displayed per page.
+     * @param length   - Total number of items, or `-1` when the total is still being calculated.
+     * @returns A formatted string such as `"1 - 25 di 100"`.
+     */
+    getRangeLabel: (page: number, pageSize: number, length: number) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorIntl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PaginatorIntl>;
+}
+
+export { PaginatorIntl };

package/types/arsedizioni-ars-utils-ui.shell.d.ts

@@ -0,0 +1,345 @@
+import { Observable } from 'rxjs';
+import * as _angular_core from '@angular/core';
+
+/**
+ * Content of a shell message.
+ *
+ * Deliberately a subset of `InfoDialogData`: the shell speaks before a route exists, so it
+ * says one thing and offers one way out. Anything richer belongs to `DialogService`.
+ */
+interface ShellMessageData {
+    /** Heading shown above the message. */
+    title?: string;
+    /** HTML body of the message. */
+    message: string;
+    /** Optional technical detail (a log, a stack trace) shown in a secondary panel. */
+    details?: string;
+    /** Label of the dismiss button. */
+    okCaption?: string;
+    /** Auto-dismiss delay in milliseconds; the message stays until dismissed when omitted. */
+    dismissAfter?: number;
+    /** Maximum width of the panel in pixels. */
+    width?: number;
+}
+/**
+ * Handle over an open shell message.
+ *
+ * Not a `MatDialogRef`: there is no Material here, and the shell never needs to reach into
+ * the component instance. Closing it and knowing when it closed is the whole contract.
+ */
+interface ShellMessageRef {
+    /**
+     * Closes the message. Does nothing when it has already been closed.
+     * @returns void
+     */
+    close(): void;
+    /** Resolves once the message has been removed from the DOM. */
+    readonly closed: Promise<void>;
+}
+
+/** Visual style of the busy indicator. */
+type ShellBusyType = 'bar' | 'spinner' | 'wait' | 'hourglass';
+/** Progress mode of the bar and of the spinner. */
+type ShellBusyMode = 'determinate' | 'indeterminate';
+/**
+ * Overlay that blocks interaction while an operation is running, in the four styles the
+ * applications use: progress bar, spinner, hourglass and bare wait.
+ *
+ * Reproduces `mat-progress-bar` and `mat-progress-spinner` in CSS and SVG rather than importing
+ * them, because this overlay is shown from the boot path — an HTTP interceptor calls it before
+ * any route exists — and `ui.shell` exists precisely so that path costs no Material.
+ *
+ * The instance is created once by {@link ShellService} and then reused: showing and hiding is a
+ * class on the host, never a `createComponent`, so the 40-odd calls a screen costs nothing.
+ */
+declare class ShellBusyComponent {
+    /** Whether the overlay is on screen. Hidden with `display: none`, so it costs no layout. */
+    readonly visible: _angular_core.WritableSignal<boolean>;
+    /** Visual style of the indicator. */
+    readonly type: _angular_core.WritableSignal<ShellBusyType>;
+    /** Current progress value (0-100), used when {@link progressMode} is `'determinate'`. */
+    readonly progress: _angular_core.WritableSignal<number>;
+    /** Progress mode of the bar and of the spinner. */
+    readonly progressMode: _angular_core.WritableSignal<ShellBusyMode>;
+    /** Message displayed above the indicator. */
+    readonly message: _angular_core.WritableSignal<string>;
+    /** Circumference of the spinner circle, bound to `stroke-dasharray`. */
+    protected readonly circumference: number;
+    /** Length of the spinner arc still to be drawn, derived from {@link progress}. */
+    protected readonly dashOffset: _angular_core.Signal<number>;
+    /**
+     * Updates the overlay state.
+     *
+     * Same contract as the `BusyDialogComponent` it replaces, down to the two implicit rules that
+     * callers rely on: an empty message keeps the previous text (so `wait()` does not wipe it), and
+     * a progress above zero forces `'determinate'` whatever the caller passed.
+     * @param message      - New message to display. An empty string preserves the current one.
+     * @param progress     - Current progress value (0-100). Above zero it forces determinate mode.
+     * @param progressMode - Progress mode to use. Defaults to `'indeterminate'`.
+     * @param type         - Visual style to use. Defaults to `'bar'`.
+     * @returns void
+     */
+    set(message: string, progress: number, progressMode?: ShellBusyMode, type?: ShellBusyType): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShellBusyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShellBusyComponent, "ars-shell-busy", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Everything the application can say to the user without asking anything back: a message, an
+ * error, and the wait overlay. No Angular Material behind any of it.
+ *
+ * `DialogService` extends this class, so a route component injects `DialogService` and has both
+ * halves; shell, HTTP interceptors, route guards and app initializers inject `ShellService` and
+ * pay for neither `mat-dialog` nor `cdk/overlay` on the boot path — measured at 445 KB of the
+ * 905 KB initial bundle on myARS, more than every route of the application put together.
+ *
+ * The methods keep the parameter order of the `DialogService` ones they came from, so no call
+ * site changed when they moved here.
+ *
+ * ## Stacking
+ *
+ * Outside the CDK overlay stack the order is a fixed z-index: the busy overlay sits at 1090 and
+ * the message at 1100, both above the `cdk-overlay-container` (1000). So an error raised while a
+ * Material dialog is open lands on top of it, which is what an error should do, and the busy
+ * overlay covers the dialog it belongs to. The one case a fixed number cannot express is a dialog
+ * opened while the overlay is still up — `DialogService.open()` takes the busy away immediately
+ * rather than with the grace period, precisely so that case cannot happen.
+ */
+declare class ShellService {
+    private readonly appRef;
+    private readonly environmentInjector;
+    private messageRef?;
+    private messageKind?;
+    private resolveClosed?;
+    private previousOverflow?;
+    private previouslyFocused?;
+    private busyRef?;
+    private busyVisible;
+    private busyActionSubscription?;
+    private clearBusyTimer?;
+    /**
+     * Shows an informational message.
+     * @param message      - HTML message to display.
+     * @param title        - Heading. Defaults to `'Informazioni'`.
+     * @param okCaption    - Dismiss button label. Defaults to `'Ok'`.
+     * @param width        - Maximum panel width in pixels. Defaults to `500`.
+     * @param dismissAfter - Auto-close delay in milliseconds (optional).
+     * @param details      - Optional secondary details text.
+     * @returns A handle over the open message, or `null` outside the browser.
+     */
+    info(message: string, title?: string, okCaption?: string, width?: number, dismissAfter?: number, details?: string): ShellMessageRef | null;
+    /**
+     * Shows an error message. When one is already on screen its content is replaced in place: a
+     * failing API answers many requests at once, and each of them must not add a panel of its own.
+     * @param message      - HTML error message to display.
+     * @param log          - Optional technical log or stack trace shown in the details panel.
+     * @param title        - Heading. Defaults to `'Errore'`.
+     * @param okCaption    - Dismiss button label. Defaults to `'Ok'`.
+     * @param width        - Maximum panel width in pixels. Defaults to `500`.
+     * @param dismissAfter - Auto-close delay in milliseconds (optional).
+     * @returns A handle over the open message, or `null` outside the browser.
+     */
+    error(message: string, log?: string, title?: string, okCaption?: string, width?: number, dismissAfter?: number): ShellMessageRef | null;
+    /**
+     * Closes the message currently on screen, if any. Does not touch the busy overlay.
+     * @returns void
+     */
+    closeMessage(): void;
+    /**
+     * Opens the message panel, or updates the one already open when it is showing the same kind of
+     * message.
+     * @param kind - Whether this is an informational or an error message.
+     * @param data - The content to display.
+     * @returns A handle over the open message, or `null` outside the browser.
+     */
+    private showMessage;
+    /**
+     * Builds the handle returned to callers, wiring its `closed` promise to the current message.
+     * @returns The handle over the message currently on screen.
+     */
+    private messageHandle;
+    /**
+     * Shows or updates the busy overlay.
+     *
+     * Called dozens of times per screen, so it creates nothing after the first time: the component
+     * is built once and then kept, and showing it again is a class on the host element. The state
+     * is written to signals and checked synchronously before returning, so the message on screen is
+     * always the last one asked for — a second `busy()` in the same task never leaves the previous
+     * text behind.
+     * @param message      - Text to display. An empty string keeps the current one.
+     * @param progress     - Progress value (`-1` = indeterminate). Defaults to `-1`.
+     * @param progressMode - Progress mode. Defaults to `'indeterminate'`.
+     * @param type         - Visual style of the overlay. Defaults to `'bar'`.
+     * @param action       - Optional observable; the overlay is dismissed when it first emits. It
+     *                       replaces the one passed to a previous call, which is unsubscribed.
+     * @returns `true` if the overlay was brought up by this call, `false` if it was already up.
+     */
+    setBusy(message: string, progress?: number, progressMode?: ShellBusyMode, type?: ShellBusyType, action?: Observable<unknown>): boolean;
+    /**
+     * Shows or updates the busy overlay using the progress-bar style.
+     * @param message      - Text to display inside the overlay.
+     * @param progress     - Progress value (`-1` = indeterminate). Defaults to `-1`.
+     * @param progressMode - Progress mode. Defaults to `'indeterminate'`.
+     * @param action       - Optional observable; the overlay is dismissed when it emits.
+     * @returns `true` if the overlay was brought up by this call.
+     */
+    busy(message: string, progress?: number, progressMode?: ShellBusyMode, action?: Observable<unknown>): boolean;
+    /**
+     * Shows or updates the busy overlay using the spinner style.
+     * @param message      - Text to display inside the overlay.
+     * @param progress     - Progress value (`-1` = indeterminate). Defaults to `-1`.
+     * @param progressMode - Progress mode. Defaults to `'indeterminate'`.
+     * @param action       - Optional observable; the overlay is dismissed when it emits.
+     * @returns `true` if the overlay was brought up by this call.
+     */
+    busySpinner(message: string, progress?: number, progressMode?: ShellBusyMode, action?: Observable<unknown>): boolean;
+    /**
+     * Shows or updates the busy overlay using the hourglass style.
+     * @param message - Text to display inside the overlay.
+     * @param action  - Optional observable; the overlay is dismissed when it emits.
+     * @returns `true` if the overlay was brought up by this call.
+     */
+    busyHourglass(message: string, action?: Observable<unknown>): boolean;
+    /**
+     * Shows a bare wait indicator, with no panel and no message.
+     * @param action - Optional observable; the overlay is dismissed when it emits.
+     * @returns `true` if the overlay was brought up by this call.
+     */
+    wait(action?: Observable<unknown>): boolean;
+    /**
+     * Returns a {@link BusyTimer} that brings the overlay up only if the operation is still running
+     * after a debounce delay.
+     * @param message - Text to display. Defaults to `'Operazione in corso...'`.
+     * @param due     - Delay in milliseconds before the overlay appears. Defaults to `100`.
+     * @returns A timer that must be disposed with `clear()` when the operation ends.
+     */
+    busyTimer(message?: string, due?: number): BusyTimer;
+    /**
+     * Takes the busy overlay away.
+     *
+     * By default it waits a short grace period, so that a chain of quick operations does not make
+     * the overlay blink between one and the next; any `setBusy()` in the meantime cancels the
+     * pending removal. Pass `true` when something is about to be drawn underneath it and the wait
+     * would be visible — that is what `DialogService.open()` does.
+     * @param immediate - When `true`, removes the overlay without waiting for the grace period.
+     * @returns void
+     */
+    clearBusy(immediate?: boolean): void;
+    /**
+     * Hides the busy overlay without destroying it, so the next call can reuse the instance.
+     * @returns void
+     */
+    private hideBusy;
+    /**
+     * Returns the busy component, creating and attaching it the first time it is needed.
+     * @returns The reused busy component reference.
+     */
+    private ensureBusy;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShellService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShellService>;
+}
+
+/**
+ * Shows the busy overlay only if the operation is still running after a debounce delay, so that
+ * an operation that answers in 30 ms never makes the screen flash.
+ *
+ * Whoever creates one owns it: {@link clear} must be called when the operation ends, otherwise
+ * the overlay appears after the fact and stays.
+ */
+declare class BusyTimer {
+    private readonly shellService;
+    private readonly subscription;
+    /**
+     * Arms the timer.
+     * @param shellService - The service that owns the overlay. A `DialogService` is accepted too,
+     *                       since it extends `ShellService`.
+     * @param due          - Delay in milliseconds before the overlay appears. Defaults to `100`.
+     * @param message      - Text to display. Defaults to `'Operazione in corso...'`.
+     */
+    constructor(shellService: ShellService, due?: number, message?: string);
+    /**
+     * Disarms the timer and takes the overlay away.
+     * @returns void
+     */
+    clear(): void;
+}
+
+/**
+ * The shell's message panel: a modal that looks like a Material dialog and owes nothing to
+ * Material.
+ *
+ * It exists because shell, interceptors, guards and app initializers must be able to say
+ * "the session is gone" before a single route has been loaded, and paying for `mat-dialog`,
+ * `cdk/overlay` and the rest of that stack on the boot path costs the initial bundle more
+ * than every route of the application put together. The look is matched through CSS custom
+ * properties (`--ars-*` first, Material's `--mat-sys-*` next, a literal last), so an
+ * application that themes Material gets the same surface here for free.
+ *
+ * Instantiated imperatively by {@link ShellService}, never declared in a template: that is
+ * what lets an interceptor open it.
+ */
+declare class ShellMessageComponent {
+    /** Emitted when the user dismisses the message, whichever way they did it. */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private readonly panel;
+    private readonly okButton;
+    /** Unique id tying the panel to its heading for assistive technology. */
+    protected readonly titleId: string;
+    /** Current content, with the defaults the shell relies on already applied. */
+    protected readonly data: _angular_core.WritableSignal<ShellMessageData>;
+    /** True for a moment after a successful copy, so the button can acknowledge it. */
+    protected readonly copied: _angular_core.WritableSignal<boolean>;
+    private dismissTimer?;
+    private copiedTimer?;
+    private closing;
+    constructor();
+    /**
+     * Replaces the content shown by the panel and restarts the auto-dismiss timer.
+     *
+     * Called on an already open panel by `ShellService.error()` so that a burst of failures
+     * updates one message instead of stacking modals nobody can dismiss.
+     * @param data - The new content to display.
+     * @returns void
+     */
+    setData(data: ShellMessageData): void;
+    /**
+     * Dismisses the panel. Safe to call more than once: only the first call is announced.
+     * @returns void
+     */
+    close(): void;
+    /**
+     * Closes the panel on Escape, mirroring a Material dialog opened with the default config.
+     * @param e - The keyboard event captured at document level.
+     * @returns void
+     */
+    protected onKeydown(e: KeyboardEvent): void;
+    /**
+     * Keeps Tab inside the panel while the message is up.
+     *
+     * A hand-rolled two-element version of what `cdk/a11y` does, which is all this panel needs:
+     * it never holds more than the copy button and the dismiss button.
+     * @param e - The Tab keydown event.
+     * @returns void
+     */
+    private trapFocus;
+    /**
+     * (Re)schedules the auto-dismiss timer, cancelling any pending one so a timer armed for an
+     * earlier message can never close a newer one.
+     * @param dismissAfter - Delay in milliseconds; no-op when falsy.
+     * @returns void
+     */
+    private scheduleDismiss;
+    /**
+     * Copies the message and its details to the clipboard, as both HTML and plain text.
+     *
+     * Unlike `InfoDialogComponent` there is no toast to report the outcome — the shell has no
+     * toast — so the button itself acknowledges it for a moment.
+     * @returns A promise that resolves once the copy has been attempted.
+     */
+    protected copy(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShellMessageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShellMessageComponent, "ars-shell-message", never, {}, { "closed": "closed"; }, never, never, true, never>;
+}
+
+export { BusyTimer, ShellBusyComponent, ShellMessageComponent, ShellService };
+export type { ShellBusyMode, ShellBusyType, ShellMessageData, ShellMessageRef };

package/types/arsedizioni-ars-utils-ui.tinymce.d.ts

@@ -0,0 +1,63 @@
+import * as _angular_core from '@angular/core';
+
+declare class TinymceUtils {
+    /**
+     * Returns `true` when the user agent currently prefers a dark color scheme.
+     * Evaluated on demand (not frozen at module load) and SSR-safe.
+     */
+    private static prefersDark;
+    /** URL of the TinyMCE script hosted on the Tiny Cloud CDN. */
+    static readonly CDN_URL = "https://cdn.tiny.cloud/1/5lnoc6ohmpjau6zyzgqyhyf52cueoennkcs8v1yfoak57ku9/tinymce/7/tinymce.min.js";
+    /** URL of the locally bundled TinyMCE script. */
+    static readonly LOCAL_URL = "/assets/tinymce/tinymce.min.js";
+    /**
+     * Full-featured TinyMCE base configuration with all standard plugins and toolbar.
+     */
+    static TinymceConfig: Record<string, any>;
+    /**
+     * Compact TinyMCE configuration with autoresize, bottom toolbar, and grouped toolbar buttons.
+     * Extends `TinymceConfig` with reduced height and a simplified toolbar.
+     */
+    static TinymceCompactConfig: Record<string, any>;
+    /**
+     * Extended compact TinyMCE configuration that adds fullscreen support and an insert group.
+     * Extends `TinymceCompactConfig`.
+     */
+    static TinymceCompactExtendedConfig: Record<string, any>;
+    /**
+     * Inject the TinyMCE script tag into the document head if it is not already present.
+     * @param useCDN - When `true`, loads from the Tiny Cloud CDN; otherwise uses the local asset.
+     */
+    static loadTinyMCEScript(useCDN?: boolean): void;
+}
+
+interface FullScreenEditorDialogData {
+    text: string;
+    configuration: Record<string, any>;
+    infoButtonLabel?: string;
+    onShowInfo?: Function;
+    disabled?: boolean;
+}
+declare class FullScreenEditorComponent {
+    /** Emitted with the edited text when the user saves. */
+    readonly saving: _angular_core.OutputEmitterRef<string>;
+    private readonly dialogRef;
+    /** Dialog configuration, injected and exposed as a signal. */
+    protected readonly dialogData: _angular_core.WritableSignal<FullScreenEditorDialogData>;
+    /** Whether the editor is in read-only mode. */
+    protected readonly disabled: _angular_core.WritableSignal<boolean>;
+    /** Current editor content, kept as a plain field for [(ngModel)] two-way binding. */
+    protected text: string;
+    /** TinyMCE editor configuration. */
+    protected tinymceConfig: Record<string, any>;
+    constructor();
+    /**
+     * Save the current editor content and close the dialog.
+     */
+    protected ok(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FullScreenEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FullScreenEditorComponent, "ng-component", never, {}, { "saving": "saving"; }, never, never, true, never>;
+}
+
+export { FullScreenEditorComponent, TinymceUtils };
+export type { FullScreenEditorDialogData };

package/types/arsedizioni-ars-utils.d.ts

@@ -1,10 +1,4 @@
-export * from '@arsedizioni/ars-utils/core';
-export * from '@arsedizioni/ars-utils/ui';
-export * from '@arsedizioni/ars-utils/ui.application';
-export * from '@arsedizioni/ars-utils/support.common';
-export * from '@arsedizioni/ars-utils/support.ui';
-export * from '@arsedizioni/ars-utils/help';
-export * from '@arsedizioni/ars-utils/clipper.common';
-export * from '@arsedizioni/ars-utils/clipper.ui';
-export * from '@arsedizioni/ars-utils/tinymce';
-export * from '@arsedizioni/ars-utils/evolution.common';
+/** Version of the library, aligned with the supported Angular major. */
+declare const ARS_UTILS_VERSION = "22.1.5";
+
+export { ARS_UTILS_VERSION };

package/ui.tinymce/README.md

@@ -0,0 +1,12 @@
+in application:
+1) install tinymce (npm install tinymce)
+1) install @tinymce/tinymce-angular (npm install @tinymce/tinymce-angular)
+2) setup assets in angular.json
+    {
+        "glob": "**/*",
+        "input": "node_modules/tinymce",
+        "output": "assets/tinymce"
+    }
+3) download language from 
+https://github.com/tinymce/tinymce/blob/develop/modules/tinymce/src/langs/it.js and put it in
+"assets/tinymce/langs/it.js"