[IMP] Renderer: add Renderer for modifiers.

Gorash · dmo-odoo · commit 470fc4b361c1 · 2020-07-09T12:13:53.000+02:00
diff --git a/packages/core/src/Modifier.ts b/packages/core/src/Modifier.ts
@@ -1,6 +1,14 @@
 import { Constructor } from '../../utils/src/utils';
 import { VNode } from './VNodes/VNode';
 
+export type ModifierTypeguard<T extends Modifier> = (
+    modifier: Modifier,
+    batch: VNode[],
+) => modifier is T;
+export type ModifierPredicate<T = Modifier | boolean> = T extends Modifier
+    ? Constructor<T> | ModifierTypeguard<T>
+    : (modifier: Modifier, batch: VNode[]) => boolean;
+
 interface ModifierConstructor {
     new <T extends Constructor<Modifier>>(...args: ConstructorParameters<T>): this;
 }
diff --git a/packages/plugin-html/src/DefaultHtmlDomModifierRenderer.ts b/packages/plugin-html/src/DefaultHtmlDomModifierRenderer.ts
@@ -0,0 +1,22 @@
+import { AbstractModifierRenderer } from '../../plugin-renderer/src/AbstractModifierRenderer';
+import { Modifier } from '../../core/src/Modifier';
+import { HtmlDomRenderingEngine } from './HtmlDomRenderingEngine';
+
+export class DefaultHtmlDomModifierRenderer extends AbstractModifierRenderer<Node[]> {
+    static id = 'dom/html';
+    engine: HtmlDomRenderingEngine;
+
+    /**
+     * Default rendering for Format.
+     *
+     * @param modifier
+     * @param contents
+     */
+    async render(modifier: Modifier, contents: Node[][]): Promise<Node[]> {
+        const flatten: Node[] = [];
+        for (const nodes of contents) {
+            flatten.push(...nodes);
+        }
+        return flatten;
+    }
+}
diff --git a/packages/plugin-html/src/HtmlDomRenderingEngine.ts b/packages/plugin-html/src/HtmlDomRenderingEngine.ts
@@ -1,12 +1,14 @@
 import { RenderingEngine } from '../../plugin-renderer/src/RenderingEngine';
 import { DefaultHtmlDomRenderer } from './DefaultHtmlDomRenderer';
+import { DefaultHtmlDomModifierRenderer } from './DefaultHtmlDomModifierRenderer';
 import { VNode } from '../../core/src/VNodes/VNode';
 import { Renderer } from '../../plugin-renderer/src/Renderer';
 import { DomObjectRenderingEngine } from '../../plugin-renderer-dom-object/src/DomObjectRenderingEngine';
 
 export class HtmlDomRenderingEngine extends RenderingEngine<Node[]> {
     static id = 'dom/html';
     static readonly defaultRenderer = DefaultHtmlDomRenderer;
+    static readonly defaultModifierRenderer = DefaultHtmlDomModifierRenderer;
 
     /**
      * Render the given node.
diff --git a/packages/plugin-renderer-dom-object/src/DefaultDomObjectModifierRenderer.ts b/packages/plugin-renderer-dom-object/src/DefaultDomObjectModifierRenderer.ts
@@ -0,0 +1,22 @@
+import { AbstractModifierRenderer } from '../../plugin-renderer/src/AbstractModifierRenderer';
+import { Modifier } from '../../core/src/Modifier';
+import { DomObjectRenderingEngine, DomObject } from './DomObjectRenderingEngine';
+
+export class DefaultDomObjectModifierRenderer extends AbstractModifierRenderer<DomObject> {
+    static id = 'dom/object';
+    engine: DomObjectRenderingEngine;
+
+    /**
+     * Default rendering for Modifier.
+     *
+     * @param modifier
+     * @param contents
+     */
+    async render(modifier: Modifier, contents: DomObject[]): Promise<DomObject> {
+        if (contents.length === 1) {
+            return contents[0];
+        } else {
+            return { children: contents };
+        }
+    }
+}
diff --git a/packages/plugin-renderer-dom-object/src/DomObjectRenderer.ts b/packages/plugin-renderer-dom-object/src/DomObjectRenderer.ts
@@ -4,10 +4,12 @@ import { Parser } from '../../plugin-parser/src/Parser';
 import { Renderer } from '../../plugin-renderer/src/Renderer';
 import { Xml } from '../../plugin-xml/src/Xml';
 import { DomObjectRenderingEngine } from './DomObjectRenderingEngine';
+import { FormatDomObjectModifierRenderer } from './FormatDomObjectModifierRenderer';
 
 export class DomObjectRenderer<T extends JWPluginConfig = JWPluginConfig> extends JWPlugin<T> {
     static dependencies = [Parser, Renderer, Xml];
     readonly loadables: Loadables<Parser & Renderer> = {
         renderingEngines: [DomObjectRenderingEngine],
+        renderers: [FormatDomObjectModifierRenderer],
     };
 }
diff --git a/packages/plugin-renderer-dom-object/src/DomObjectRenderingEngine.ts b/packages/plugin-renderer-dom-object/src/DomObjectRenderingEngine.ts
@@ -1,11 +1,13 @@
-import { RenderingEngine, Renderer } from '../../plugin-renderer/src/RenderingEngine';
+import { RenderingEngine, RenderingIdentifier } from '../../plugin-renderer/src/RenderingEngine';
 import { DefaultDomObjectRenderer } from './DefaultDomObjectRenderer';
+import { DefaultDomObjectModifierRenderer } from './DefaultDomObjectModifierRenderer';
 import { VNode } from '../../core/src/VNodes/VNode';
 import { AtomicNode } from '../../core/src/VNodes/AtomicNode';
 import { Attributes } from '../../plugin-xml/src/Attributes';
 import { AbstractNode } from '../../core/src/VNodes/AbstractNode';
 import { Format } from '../../core/src/Format';
 import { flat } from '../../utils/src/utils';
+import { AbstractRenderer } from '../../plugin-renderer/src/AbstractRenderer';
 
 /**
  * Renderer a node can define the location when define the nodes attributes.
@@ -214,11 +216,12 @@ export type DomObjectNative = {
 };
 export type DomObject = DomObjectElement | DomObjectFragment | DomObjectText | DomObjectNative;
 
-type RenderingBatchUnit = [VNode, Format[], Renderer<DomObject>];
+type RenderingBatchUnit = [VNode, Format[], AbstractRenderer<DomObject>];
 
 export class DomObjectRenderingEngine extends RenderingEngine<DomObject> {
-    static readonly id = 'dom/object';
+    static readonly id: RenderingIdentifier = 'dom/object';
     static readonly defaultRenderer = DefaultDomObjectRenderer;
+    static readonly defaultModifierRenderer = DefaultDomObjectModifierRenderer;
     /**
      * Render the attributes of the given VNode onto the given DOM Element.
      *
@@ -305,40 +308,14 @@ export class DomObjectRenderingEngine extends RenderingEngine<DomObject> {
             }
         }
     }
-    /**
-     * Wrap list of DomObject into a formating DomObject.
-     *
-     * @param renderings
-     * @param format
-     */
-    async renderFormat(renderings: DomObject[], format: Format): Promise<DomObject> {
-        if (format) {
-            const domObject: DomObject = {
-                tag: format.htmlTag.toUpperCase(),
-                attributes: {},
-                children: renderings,
-            };
-            const attributes = format.modifiers.find(Attributes);
-            if (attributes) {
-                for (const name of attributes.keys()) {
-                    domObject.attributes[name] = attributes.get(name);
-                }
-            }
-            return domObject;
-        } else if (renderings.length === 1) {
-            return renderings[0];
-        } else {
-            return { children: renderings };
-        }
-    }
     /**
      * Group the nodes by renderer, siblings and format.
      *
      * @override
      */
     renderBatched(
         nodes: VNode[],
-        rendered?: Renderer<DomObject>,
+        rendered?: AbstractRenderer<DomObject>,
     ): [VNode[], Promise<DomObject[]>][] {
         const renderingUnits = this._getRenderingUnits(nodes, rendered);
         return this._renderBatched(renderingUnits);
@@ -392,13 +369,14 @@ export class DomObjectRenderingEngine extends RenderingEngine<DomObject> {
                         }
                     }
                     // Create format.
-                    const rendering = await this.renderFormat(domObjects, format);
+                    const modifierRenderer = this.getCompatibleModifierRenderer(format, nodes);
+                    const rendering = await modifierRenderer.render(format, domObjects, nodes);
                     return flatten.map(() => rendering);
                 });
                 renderings.push([nodes, unitPromise]);
             } else {
                 // Render each node.
-                let currentRenderer: Renderer<DomObject>;
+                let currentRenderer: AbstractRenderer<DomObject>;
                 let renderingUnit: RenderingBatchUnit;
                 const siblings: VNode[] = [];
                 while (
@@ -433,7 +411,7 @@ export class DomObjectRenderingEngine extends RenderingEngine<DomObject> {
      */
     private _getRenderingUnits(
         nodes: VNode[],
-        rendered?: Renderer<DomObject>,
+        rendered?: AbstractRenderer<DomObject>,
     ): RenderingBatchUnit[] {
         // Consecutive char nodes are rendered in same time.
         const renderingUnits: RenderingBatchUnit[] = [];
diff --git a/packages/plugin-renderer-dom-object/src/FormatDomObjectModifierRenderer.ts b/packages/plugin-renderer-dom-object/src/FormatDomObjectModifierRenderer.ts
@@ -0,0 +1,31 @@
+import { AbstractModifierRenderer } from '../../plugin-renderer/src/AbstractModifierRenderer';
+import { DomObjectRenderingEngine, DomObject } from './DomObjectRenderingEngine';
+import { Format } from '../../core/src/Format';
+import { Attributes } from '../../plugin-xml/src/Attributes';
+
+export class FormatDomObjectModifierRenderer extends AbstractModifierRenderer<DomObject> {
+    static id = DomObjectRenderingEngine.id;
+    engine: DomObjectRenderingEngine;
+    predicate = Format;
+
+    /**
+     * Rendering for Format Modifier.
+     *
+     * @param format
+     * @param contents
+     */
+    async render(format: Format, contents: DomObject[]): Promise<DomObject> {
+        const domObject: DomObject = {
+            tag: format.htmlTag.toUpperCase(),
+            attributes: {},
+            children: contents,
+        };
+        const attributes = format.modifiers.find(Attributes);
+        if (attributes) {
+            for (const name of attributes.keys()) {
+                domObject.attributes[name] = attributes.get(name);
+            }
+        }
+        return domObject;
+    }
+}
diff --git a/packages/plugin-renderer/src/AbstractModifierRenderer.ts b/packages/plugin-renderer/src/AbstractModifierRenderer.ts
@@ -0,0 +1,54 @@
+import { RenderingIdentifier } from './RenderingEngine';
+import { RenderingEngine } from './RenderingEngine';
+import { Modifier } from '../../core/src/Modifier';
+import { ModifierPredicate } from '../../core/src/Modifier';
+import { VNode } from '../../core/src/VNodes/VNode';
+
+class SuperModifierRenderer<T> {
+    constructor(public renderer: AbstractModifierRenderer<T>) {}
+    /**
+     * Render the given modifier and wrap the list of DomObject into a
+     * formating DomObject.
+     *
+     * @param modifier
+     * @param contents
+     * @param batch
+     */
+    render(modifier: Modifier, contents: T[], batch: VNode[]): Promise<T> {
+        const nextRenderer = this.renderer.engine.getCompatibleModifierRenderer(
+            modifier,
+            batch,
+            this.renderer,
+        );
+        return nextRenderer?.render(modifier, contents, batch);
+    }
+}
+
+export abstract class AbstractModifierRenderer<T> {
+    static id: RenderingIdentifier;
+    readonly predicate?: ModifierPredicate;
+    readonly engine: RenderingEngine<T>;
+    readonly super: SuperModifierRenderer<T>;
+    constructor(engine: RenderingEngine<T>) {
+        this.engine = engine;
+        this.super = new SuperModifierRenderer(this);
+    }
+    /**
+     * Render the given modifier and wrap the list of DomObject into a
+     * formating DomObject.
+     *
+     * @param modifier
+     * @param contents
+     * @param batch
+     */
+    abstract render(modifier: Modifier, renderings: T[], batch: VNode[]): Promise<T>;
+}
+
+export interface AbstractModifierRenderer<T = {}> {
+    constructor: ModifierRendererConstructor<T>;
+}
+
+export type ModifierRendererConstructor<T = {}> = {
+    new (engine: RenderingEngine<T>): AbstractModifierRenderer<T>;
+    id: RenderingIdentifier;
+};
diff --git a/packages/plugin-renderer/src/AbstractRenderer.ts b/packages/plugin-renderer/src/AbstractRenderer.ts
@@ -1,11 +1,9 @@
-import { Renderer, RenderingIdentifier, RendererConstructor } from './RenderingEngine';
+import { RenderingIdentifier } from './RenderingEngine';
 import { RenderingEngine } from './RenderingEngine';
 import { VNode, Predicate } from '../../core/src/VNodes/VNode';
 import { flat } from '../../utils/src/utils';
 
-class SuperRenderer<T> implements Renderer<T> {
-    static id = 'super';
-    super: Renderer<T> = null;
+class SuperRenderer<T> {
     constructor(public renderer: AbstractRenderer<T>) {}
     /**
      * Render the given node.
@@ -35,11 +33,11 @@ interface SuperRenderer<T = {}> {
     constructor: RendererConstructor<T>;
 }
 
-export abstract class AbstractRenderer<T> implements Renderer<T> {
+export abstract class AbstractRenderer<T> {
     static id: RenderingIdentifier;
     readonly predicate?: Predicate;
     readonly engine: RenderingEngine<T>;
-    readonly super: Renderer<T>;
+    readonly super: SuperRenderer<T>;
     constructor(engine: RenderingEngine<T>) {
         this.engine = engine;
         this.super = new SuperRenderer(this);
@@ -65,3 +63,8 @@ export abstract class AbstractRenderer<T> implements Renderer<T> {
 export interface AbstractRenderer<T = {}> {
     constructor: RendererConstructor<T>;
 }
+
+export type RendererConstructor<T = {}> = {
+    new (engine: RenderingEngine<T>): AbstractRenderer<T>;
+    id: RenderingIdentifier;
+};
diff --git a/packages/plugin-renderer/src/Renderer.ts b/packages/plugin-renderer/src/Renderer.ts
@@ -1,11 +1,12 @@
 import { JWPluginConfig, JWPlugin } from '../../core/src/JWPlugin';
 import {
-    RendererConstructor,
     RenderingIdentifier,
     RenderingEngine,
     RenderingEngineConstructor,
 } from './RenderingEngine';
 import { VNode } from '../../core/src/VNodes/VNode';
+import { ModifierRendererConstructor } from './AbstractModifierRenderer';
+import { RendererConstructor } from './AbstractRenderer';
 
 export class Renderer<T extends JWPluginConfig = JWPluginConfig> extends JWPlugin<T> {
     loaders = {
@@ -22,8 +23,7 @@ export class Renderer<T extends JWPluginConfig = JWPluginConfig> extends JWPlugi
             // The caller might want to fallback on another rendering.
             return;
         }
-        engine.renderings.clear();
-        engine.locations.clear();
+        engine.clear();
         if (nodes instanceof Array) {
             return engine.render(nodes);
         } else {
@@ -42,8 +42,8 @@ export class Renderer<T extends JWPluginConfig = JWPluginConfig> extends JWPlugi
         }
     }
 
-    loadRenderers(renderers: RendererConstructor[]): void {
-        renderers = [...renderers].reverse();
+    loadRenderers(renderers: RendererConstructor[] | ModifierRendererConstructor[]): void {
+        renderers = [...renderers].reverse() as RendererConstructor[];
         for (const RendererClass of renderers) {
             for (const id in this.engines) {
                 const renderingEngine = this.engines[id];
diff --git a/packages/plugin-renderer/src/RenderingEngine.ts b/packages/plugin-renderer/src/RenderingEngine.ts
diff --git a/packages/plugin-renderer/test/Renderer.test.ts b/packages/plugin-renderer/test/Renderer.test.ts
