import { Type_JSON } from '../types/Utils'; import { Class_NodeElement } from './Node'; /** * Container display mode for a dimension. * When non-null, both parent and children are visible simultaneously; the * parent is rendered as an envelope around the children, and links are * filtered per side (see Link.is_visible). * * - 'in_children_out_parent': incoming links land on children, outgoing links leave from parent * - 'in_parent_out_children': incoming links land on parent, outgoing links leave from children * - 'in_children_out_children': incoming and outgoing links both land on children; parent is a pure visual envelope * - 'in_parent_out_parent': incoming and outgoing links both land on parent; children are visible inside the envelope but carry no flux of their own */ export type Type_ContainerMode = null | 'in_children_out_parent' | 'in_parent_out_children' | 'in_children_out_children' | 'in_parent_out_parent'; /** * #1231 — Type de désagrégation MÉMORISÉ pour une dimension (= un axe d'un nœud * parent). Enregistré à chaque désagrégation LOCALE (clic droit) : simple, * englobement (4 variantes container) ou expansion latérale. Persisté dans le * JSON, et NON effacé par l'agrégation (c'est une préférence, pas l'état courant * d'affichage). La désagrégation GLOBALE (menu Hiérarchies) le relit pour * réappliquer le même type par nœud au lieu de toujours désagréger « simple ». */ export type Type_DisaggregationKind = 'children' | Exclude | 'expanded_left' | 'expanded_right'; export declare class Class_NodeDimension { private _id; private _parent; private _children; private _force_show_children; private _force_show_parent; private _container_mode; private _expanded_left; private _expanded_right; private _preferred_disaggregation; private _forced_by_local_action; /** * True if element is currently on a deletion process * Avoid cross calls of delete() method * @private * @memberof ClassTemplate_Element */ private _is_currently_deleted; private _is_currently_in_unsetting_recursion; /** * Creates an instance of Class_NodeDimension. * @param {ClassAbstract_NodeElement} parent * @param {ClassAbstract_NodeElement[]} children * @param {Class_LevelTag} parent_level_tag * @param {Class_LevelTag} children_level_tag * @memberof Class_NodeDimension */ constructor(parent: Class_NodeElement, children: Class_NodeElement[], dimension_id: string); /** * Define deletion behavior * @memberof Class_NodeDimension */ delete(): void; synchroWith(dim: Class_NodeDimension): void; removeNodeAsParent(_: Class_NodeElement): void; addNodeAsChild(_: Class_NodeElement): void; removeNodeFromChildren(_: Class_NodeElement): void; /** * Force to set this dimension's parent as visible * @memberof Class_NodeDimension */ setForceToShowParent(): void; /** * Force to set this dimension's children as visibles * @memberof Class_NodeDimension */ setForceToShowChildren(fromJSON?: boolean): void; /** * Activate container display mode: parent and children are shown at the * same time, the parent surrounds the children, and links are filtered * per side according to the mode variant. */ setContainerMode(mode: Exclude, fromJSON?: boolean): void; /** * Set the container_mode flag in place, without any side effect: * no style application, no geometry snapshot, no redraw, no link * reorganization. Used by view-switch sync (UpdateFrom), where the * visual style is already transferred via replaceStyles and the * caller will trigger a full draw afterwards. */ setContainerModeQuiet(mode: Type_ContainerMode): void; /** * #1231 — Retire le style de nœud-cadre (NodeContainerStyle) du parent quand on * QUITTE le mode englobant. À appeler TANT QUE `_container_mode` est encore non-null * (lit l'état courant). Sans ça, sortir du mode englobant par un autre chemin que * `unsetContainerMode` (agrégation → setForceToShowParent, désagrégation simple, * expansion, `showAccordingToLevelTags` → unsetForcingToShow, c.-à-d. via le menu * Hiérarchies) laissait le style « cadre » (fond transparent, bord pointillé) collé * au nœud. Ne retire le style que si AUCUNE autre dimension du parent n'est englobante. */ private _removeContainerStyleIfLeaving; /** * Exit container display mode and reset to a neutral state (no forcing). */ unsetContainerMode(): void; /** * Activate lateral expansion display: parent stays visible AND its children * appear on the chosen side, with explicit expansion links (parent↔children) * carrying redistributed values from the parent's external links. * * Mutually exclusive with force_show_*, container_mode, and the opposite side. */ setExpandedSide(side: 'left' | 'right', fromJSON?: boolean): void; /** * Exit expansion mode and reset to a neutral state. */ unsetExpansion(): void; protected _updated(): void; unsetForcingToShow(): void; get id(): string; get name(): string; get short_name(): string; get children_name(): string; get parent(): Class_NodeElement; set parent(_: Class_NodeElement); get has_children(): boolean; get children(): Class_NodeElement[]; get force_show_parent(): boolean; get force_show_children(): boolean; get container_mode(): Type_ContainerMode; get expanded_left(): boolean; get expanded_right(): boolean; get is_expanded(): boolean; get expansion_side(): 'left' | 'right' | null; get preferred_disaggregation(): Type_DisaggregationKind | null; set preferred_disaggregation(_: Type_DisaggregationKind | null); get forced_by_local_action(): boolean; set forced_by_local_action(_: boolean); normalize(): void; } /** * Class that handles all dimension management operations for NodeElement */ export declare class NodeDimensionsManager { private _node; constructor(node: Class_NodeElement); cleanForDeletion(): void; copyDimensionsFrom(node_to_copy: Class_NodeElement): void; toJSON(json_object: Type_JSON): void; fromJSON(json_node_object: Type_JSON, create_tag: boolean, matching_nodes_id?: { [_: string]: string; }, _matching_taggs_id?: { [_: string]: string; }, __matching_tags_id?: { [_: string]: { [_: string]: string; }; }): void; /** * sa#283 lot 5 — ÉTAT DE DIMENSION de ce nœud, sur la forme EXACTE de `toJSON` : * `{ '': { parent_name, force_show_children | force_show_parent | * container_mode | expanded_left | expanded_right, preferred_disaggregation } }`. * * C'est la TROISIÈME catégorie de données qui peut différer d'une tranche à l'autre, à * côté des attributs du sac `_storage` et de la présence de l'élément : la place du nœud * dans la hiérarchie d'agrégation, et l'état d'affichage de la dimension qui l'y relie. * Elle ne vit PAS dans `_storage` (rien ne la capturait), et gouverne la visibilité par * `checkIfRelatedDimensionsAreSelected`. * * @param dimension_ids restreint le résultat à ces dimensions ; une dimension citée mais * dont le nœud n'a aucune relation vaut `{}` (= détaché). Sans argument, toutes les * dimensions écrites par `toJSON`. */ dimensionsStateToJSON(dimension_ids?: string[]): Type_JSON; /** * sa#283 lot 5 — REMPLACE l'état de dimension de ce nœud pour les DIMENSIONS CITÉES, et * elles seules. Exactement réversible : `applyDimensionsState(dimensionsStateToJSON(ids))` * est un no-op, et rejouer l'état mémorisé avant l'écriture rend l'état d'origine. * * Par dimension citée : * 1. PARENTÉ — `parent_name` absent ⇒ le nœud est DÉTACHÉ de cette dimension ; différent * du parent courant ⇒ détaché puis rattaché au nouveau parent (créé si besoin par * `getOrCreateLowerDimension`). Un parent introuvable dans `nodes_dict` laisse le nœud * détaché — jamais de nœud fantôme (même règle qu'au chargement, cf. #193). * 2. AFFICHAGE — les états sont MUTUELLEMENT EXCLUSIFS (cf. l'en-tête de la classe) : * englobement, puis expansion, puis désagrégation, puis agrégation, sinon NEUTRE. * L'entrée est posée SUR LA DIMENSION, partagée entre le parent et TOUS ses enfants — * c'est déjà ce que fait le JSON, où chaque enfant réécrit le même drapeau. * 3. PRÉFÉRENCE mémorisée (`preferred_disaggregation`, #1231) : réinscrite telle quelle, * y compris à `null`, pour que le passage par `setForceToShowChildren` ne la salisse pas. * * INVALIDATION DU CACHE DE VISIBILITÉ — le piège de ce lot. `are_related_dimensions_selected` * MÉMOÏSE dans `_are_related_dimensions_selected` : sans invalidation, la structure change * et l'affichage ne bouge pas. Les setters de dimension appellent `_updated()` (parent + * enfants), mais pas les chemins de détachement ni le cas « rien à changer ». On invalide * donc EXPLICITEMENT le nœud, l'ancien et le nouveau parent, et tous les enfants des * dimensions touchées. Les VOISINS suivent d'eux-mêmes : `dimensionsUpdated()` renouvelle * l'empreinte de visibilité, et `getLinksVisibilitiesFingerprint` d'un voisin agrège celle * des deux extrémités de chacun de ses flux. */ applyDimensionsState(state: Type_JSON): void; getOrCreateLowerDimension(parent: Class_NodeElement, child: Class_NodeElement, dimension_id: string): Class_NodeDimension | undefined; addNewDimensionAsParent(_: Class_NodeDimension): void; addNewDimensionAsChild(_: Class_NodeDimension): void; removeDimensionAsParent(_: Class_NodeDimension): void; removeDimensionAsChild(_: Class_NodeDimension): void; nodeDimensionAsParent(child: Class_NodeElement): Class_NodeDimension | null; nodeDimensionAsChild(parent: Class_NodeElement): Class_NodeDimension | null; /** * Ce nœud porte-t-il un tag appartenant à un groupe de niveaux ACTIVÉ ? * * C'est le second moyen d'entrer dans le système de niveaux, à côté de la * parenté déclarée par une dimension. Un fichier peut n'exprimer un axe * d'agrégation que par les TAGS, sans jamais déclarer de `parent_name` : * c'est le cas des nœuds d'échange de Bois Savoie, où les variantes * « Séparés » (`…-InternationalExportations`, * `…-AutresRegionsFrancaisesExportations`) portent le tag mais aucune * dimension, alors que la variante « Ensemble » en porte une. */ private hasTagOfActivatedLevelGroup; /** * Check if, based on level tags or dimension, we must show or hide this node */ checkIfRelatedDimensionsAreSelected(): boolean; setTradeDimensions(importation: boolean): void; /** * Check if node is child in any dimension */ get is_child(): boolean; /** * Check if node is parent in any dimension */ get is_parent(): boolean; /** * Return true if node is in multiple nodeDimension as a parent */ get is_multi_parent(): boolean; /** * Return list of dimensions where this node is the parent */ get dimensions_as_parent(): Class_NodeDimension[]; /** * Return true if node is in multiple nodeDimension as a child */ get is_multi_children(): boolean; /** * Return list of dimensions where this node is a child */ get dimensions_as_child(): Class_NodeDimension[]; }