slate-angular 15.1.3 → 16.1.0-next

package/components/block-card/block-card.component.d.ts

@@ -1,6 +1,6 @@
 import { ElementRef, OnInit } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare class SlateBlockCardComponent implements OnInit {
+export declare class SlateBlockCard implements OnInit {
     private elementRef;
     centerContianer: ElementRef;
     centerRootNodes: HTMLElement[];
@@ -10,6 +10,6 @@ export declare class SlateBlockCardComponent implements OnInit {
     ngOnInit(): void;
     append(): void;
     initializeCenter(rootNodes: HTMLElement[]): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SlateBlockCardComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SlateBlockCardComponent, "slate-block-card, [slateBlockCard]", never, {}, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlateBlockCard, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlateBlockCard, "slate-block-card, [slateBlockCard]", never, {}, {}, never, never, true, never>;
 }

package/components/children/children.component.d.ts

@@ -1,16 +1,16 @@
 import { OnInit, QueryList } from '@angular/core';
-import { SlateDescendantComponent } from '../descendant/descendant.component';
+import { SlateDescendant } from '../descendant/descendant.component';
 import { Descendant } from 'slate';
 import { SlateChildrenContext, SlateViewContext } from '../../view/context';
 import { ViewContainer } from '../../view/container';
 import * as i0 from "@angular/core";
-export declare class SlateChildrenComponent extends ViewContainer<SlateDescendantComponent> implements OnInit {
+export declare class SlateChildren extends ViewContainer<SlateDescendant> implements OnInit {
     children: Descendant[];
     context: SlateChildrenContext;
     viewContext: SlateViewContext;
-    childrenComponent: QueryList<SlateDescendantComponent>;
+    childrenComponent: QueryList<SlateDescendant>;
     ngOnInit(): void;
     trackBy: (index: any, node: any) => any;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SlateChildrenComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SlateChildrenComponent, "slate-children", never, { "children": "children"; "context": "context"; "viewContext": "viewContext"; }, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlateChildren, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlateChildren, "slate-children", never, { "children": { "alias": "children"; "required": false; }; "context": { "alias": "context"; "required": false; }; "viewContext": { "alias": "viewContext"; "required": false; }; }, {}, never, never, true, never>;
 }

package/components/descendant/descendant.component.d.ts

@@ -5,7 +5,7 @@ import { SlateChildrenContext, SlateElementContext, SlateTextContext, SlateViewC
 import { BaseElementComponent, BaseTextComponent } from '../../view/base';
 import { ComponentType, ViewType } from '../../types/view';
 import * as i0 from "@angular/core";
-export declare class SlateDescendantComponent extends ViewContainerItem<SlateElementContext | SlateTextContext, BaseElementComponent | BaseTextComponent> implements OnInit, OnChanges {
+export declare class SlateDescendant extends ViewContainerItem<SlateElementContext | SlateTextContext, BaseElementComponent | BaseTextComponent> implements OnInit, OnChanges {
     protected viewContainerRef: ViewContainerRef;
     defaultElementComponentType: ComponentType<BaseElementComponent>;
     descendant: Descendant;
@@ -30,6 +30,6 @@ export declare class SlateDescendantComponent extends ViewContainerItem<SlateEle
     memoizedElementContext(prev: SlateElementContext, next: SlateElementContext): boolean;
     memoizedTextContext(prev: SlateTextContext, next: SlateTextContext): boolean;
     memoizedContext(prev: SlateElementContext | SlateTextContext, next: SlateElementContext | SlateTextContext): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SlateDescendantComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SlateDescendantComponent, "slate-descendant", never, { "descendant": "descendant"; "context": "context"; "viewContext": "viewContext"; "index": "index"; }, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlateDescendant, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlateDescendant, "slate-descendant", never, { "descendant": { "alias": "descendant"; "required": false; }; "context": { "alias": "context"; "required": false; }; "viewContext": { "alias": "viewContext"; "required": false; }; "index": { "alias": "index"; "required": false; }; }, {}, never, never, true, never>;
 }

package/components/editable/editable.component.d.ts

@@ -2,12 +2,12 @@ import { OnInit, Renderer2, ElementRef, OnDestroy, ChangeDetectorRef, NgZone, In
 import { Text as SlateText, Element, Editor, Range, NodeEntry } from 'slate';
 import { AngularEditor } from '../../plugins/angular-editor';
 import { DOMElement, DOMNode, DOMRange } from '../../utils/dom';
-import { SlateStringTemplateComponent } from '../string/template.component';
+import { SlateStringTemplate } from '../string/template.component';
 import { SlateChildrenContext, SlateViewContext } from '../../view/context';
 import { ViewType } from '../../types/view';
 import { SlatePlaceholder } from '../../types/feature';
 import * as i0 from "@angular/core";
-export declare class SlateEditableComponent implements OnInit, OnChanges, OnDestroy, AfterViewChecked, DoCheck {
+export declare class SlateEditable implements OnInit, OnChanges, OnDestroy, AfterViewChecked, DoCheck {
     elementRef: ElementRef;
     renderer2: Renderer2;
     cdr: ChangeDetectorRef;
@@ -57,7 +57,7 @@ export declare class SlateEditableComponent implements OnInit, OnChanges, OnDest
     dataSlateNode: string;
     dataGramm: boolean;
     get hasBeforeInputSupport(): boolean;
-    templateComponent: SlateStringTemplateComponent;
+    templateComponent: SlateStringTemplate;
     templateElementRef: ElementRef<any>;
     constructor(elementRef: ElementRef, renderer2: Renderer2, cdr: ChangeDetectorRef, ngZone: NgZone, injector: Injector);
     ngOnInit(): void;
@@ -96,8 +96,8 @@ export declare class SlateEditableComponent implements OnInit, OnChanges, OnDest
     private onFallbackBeforeInput;
     private isDOMEventHandled;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SlateEditableComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SlateEditableComponent, "slate-editable", never, { "editor": "editor"; "renderElement": "renderElement"; "renderLeaf": "renderLeaf"; "renderText": "renderText"; "decorate": "decorate"; "placeholderDecorate": "placeholderDecorate"; "scrollSelectionIntoView": "scrollSelectionIntoView"; "isStrictDecorate": "isStrictDecorate"; "trackBy": "trackBy"; "readonly": "readonly"; "placeholder": "placeholder"; "beforeInput": "beforeInput"; "blur": "blur"; "click": "click"; "compositionEnd": "compositionEnd"; "compositionUpdate": "compositionUpdate"; "compositionStart": "compositionStart"; "copy": "copy"; "cut": "cut"; "dragOver": "dragOver"; "dragStart": "dragStart"; "dragEnd": "dragEnd"; "drop": "drop"; "focus": "focus"; "keydown": "keydown"; "paste": "paste"; "spellCheck": "spellCheck"; "autoCorrect": "autoCorrect"; "autoCapitalize": "autoCapitalize"; }, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlateEditable, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlateEditable, "slate-editable", never, { "editor": { "alias": "editor"; "required": false; }; "renderElement": { "alias": "renderElement"; "required": false; }; "renderLeaf": { "alias": "renderLeaf"; "required": false; }; "renderText": { "alias": "renderText"; "required": false; }; "decorate": { "alias": "decorate"; "required": false; }; "placeholderDecorate": { "alias": "placeholderDecorate"; "required": false; }; "scrollSelectionIntoView": { "alias": "scrollSelectionIntoView"; "required": false; }; "isStrictDecorate": { "alias": "isStrictDecorate"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "beforeInput": { "alias": "beforeInput"; "required": false; }; "blur": { "alias": "blur"; "required": false; }; "click": { "alias": "click"; "required": false; }; "compositionEnd": { "alias": "compositionEnd"; "required": false; }; "compositionUpdate": { "alias": "compositionUpdate"; "required": false; }; "compositionStart": { "alias": "compositionStart"; "required": false; }; "copy": { "alias": "copy"; "required": false; }; "cut": { "alias": "cut"; "required": false; }; "dragOver": { "alias": "dragOver"; "required": false; }; "dragStart": { "alias": "dragStart"; "required": false; }; "dragEnd": { "alias": "dragEnd"; "required": false; }; "drop": { "alias": "drop"; "required": false; }; "focus": { "alias": "focus"; "required": false; }; "keydown": { "alias": "keydown"; "required": false; }; "paste": { "alias": "paste"; "required": false; }; "spellCheck": { "alias": "spellCheck"; "required": false; }; "autoCorrect": { "alias": "autoCorrect"; "required": false; }; "autoCapitalize": { "alias": "autoCapitalize"; "required": false; }; }, {}, never, never, true, never>;
 }
 export declare const defaultScrollSelectionIntoView: (editor: AngularEditor, domRange: DOMRange) => void;
 /**

package/components/element/default-element.component.d.ts

@@ -1,6 +1,6 @@
 import { BaseElementComponent } from '../../view/base';
 import * as i0 from "@angular/core";
-export declare class SlateDefaultElementComponent extends BaseElementComponent {
-    static ɵfac: i0.ɵɵFactoryDeclaration<SlateDefaultElementComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SlateDefaultElementComponent, "div[slateDefaultElement]", never, {}, {}, never, never, false, never>;
+export declare class SlateDefaultElement extends BaseElementComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlateDefaultElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlateDefaultElement, "div[slateDefaultElement]", never, {}, {}, never, never, true, never>;
 }

package/components/element/element.component.d.ts

@@ -1,6 +1,6 @@
 import { BaseElementComponent } from '../../view/base';
 import * as i0 from "@angular/core";
-export declare class SlateElementComponent extends BaseElementComponent {
-    static ɵfac: i0.ɵɵFactoryDeclaration<SlateElementComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SlateElementComponent, "[slateElement]", never, {}, {}, never, ["*"], false, never>;
+export declare class SlateElement extends BaseElementComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlateElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlateElement, "[slateElement]", never, {}, {}, never, ["*"], true, never>;
 }

package/components/leaf/default-leaf.component.d.ts

@@ -1,9 +1,9 @@
 import { OnDestroy } from '@angular/core';
 import { BaseLeafComponent } from '../../view/base';
 import * as i0 from "@angular/core";
-export declare class SlateDefaultLeafComponent extends BaseLeafComponent implements OnDestroy {
+export declare class SlateDefaultLeaf extends BaseLeafComponent implements OnDestroy {
     onContextChange(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SlateDefaultLeafComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SlateDefaultLeafComponent, "span[slateDefaultLeaf]", never, {}, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlateDefaultLeaf, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlateDefaultLeaf, "span[slateDefaultLeaf]", never, {}, {}, never, never, true, never>;
 }

package/components/leaf/leaf.component.d.ts

@@ -4,13 +4,13 @@ import { SlateLeafContext } from '../../view/context';
 import { BaseLeafComponent } from '../../view/base';
 import { ViewType } from '../../types/view';
 import * as i0 from "@angular/core";
-export declare class SlateLeafComponent extends ViewContainerItem<SlateLeafContext, BaseLeafComponent> implements OnInit, OnChanges {
+export declare class SlateLeaf extends ViewContainerItem<SlateLeafContext, BaseLeafComponent> implements OnInit, OnChanges {
     context: SlateLeafContext;
     ngOnInit(): void;
     getContext(): SlateLeafContext;
     getViewType(): ViewType;
     memoizedContext(prev: SlateLeafContext, next: SlateLeafContext): boolean;
     ngOnChanges(simpleChanges: SimpleChanges): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SlateLeafComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SlateLeafComponent, "slate-leaf", never, { "context": "context"; }, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlateLeaf, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlateLeaf, "slate-leaf", never, { "context": { "alias": "context"; "required": false; }; }, {}, never, never, true, never>;
 }

package/components/leaves/leaves.component.d.ts

@@ -2,14 +2,14 @@ import { AfterViewInit, OnChanges, OnInit, QueryList, SimpleChanges } from '@ang
 import { Text } from 'slate';
 import { SlateLeafContext, SlateTextContext } from '../../view/context';
 import { ViewContainer } from '../../view/container';
-import { SlateLeafComponent } from '../leaf/leaf.component';
+import { SlateLeaf } from '../leaf/leaf.component';
 import * as i0 from "@angular/core";
-export declare class SlateLeavesComponent extends ViewContainer<SlateLeafComponent> implements OnInit, AfterViewInit, OnChanges {
+export declare class SlateLeaves extends ViewContainer<SlateLeaf> implements OnInit, AfterViewInit, OnChanges {
     initialized: boolean;
     leafContexts: SlateLeafContext[];
     leaves: Text[];
     context: SlateTextContext;
-    childrenComponent: QueryList<SlateLeafComponent>;
+    childrenComponent: QueryList<SlateLeaf>;
     ngOnInit(): void;
     getLeafContexts(): {
         leaf: import("slate").BaseText;
@@ -20,6 +20,6 @@ export declare class SlateLeavesComponent extends ViewContainer<SlateLeafCompone
     }[];
     ngOnChanges(simpleChanges: SimpleChanges): void;
     trackBy(index: any, item: any): any;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SlateLeavesComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SlateLeavesComponent, "slate-leaves", never, { "context": "context"; }, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlateLeaves, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlateLeaves, "slate-leaves", never, { "context": { "alias": "context"; "required": false; }; }, {}, never, never, true, never>;
 }

package/components/string/default-string.component.d.ts

@@ -4,7 +4,7 @@ import { BaseComponent } from '../../view/base';
 import { BeforeContextChange } from '../../view/before-context-change';
 import { DOMElement } from '../../utils/dom';
 import * as i0 from "@angular/core";
-export declare class SlateDefaultStringComponent extends BaseComponent<SlateStringContext> implements OnInit, BeforeContextChange<SlateStringContext> {
+export declare class SlateDefaultString extends BaseComponent<SlateStringContext> implements OnInit, BeforeContextChange<SlateStringContext> {
     elementRef: ElementRef<any>;
     cdr: ChangeDetectorRef;
     textNode?: Text;
@@ -18,6 +18,6 @@ export declare class SlateDefaultStringComponent extends BaseComponent<SlateStri
     updateStringDOM(): void;
     removeStringDOM(): void;
     ngOnInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SlateDefaultStringComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SlateDefaultStringComponent, "span[slateDefaultString]", never, {}, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlateDefaultString, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlateDefaultString, "span[slateDefaultString]", never, {}, {}, never, never, true, never>;
 }

package/components/string/string.component.d.ts

@@ -1,9 +1,9 @@
 import { OnInit, OnChanges, ElementRef, ViewContainerRef, AfterViewInit } from '@angular/core';
 import { ViewContainerItem } from '../../view/container-item';
 import { SlateLeafContext, SlateStringContext } from '../../view/context';
-import { SlateDefaultStringComponent } from './default-string.component';
+import { SlateDefaultString } from './default-string.component';
 import * as i0 from "@angular/core";
-export declare class SlateStringComponent extends ViewContainerItem<SlateStringContext> implements OnInit, OnChanges, AfterViewInit {
+export declare class SlateString extends ViewContainerItem<SlateStringContext> implements OnInit, OnChanges, AfterViewInit {
     private elementRef;
     protected viewContainerRef: ViewContainerRef;
     context: SlateLeafContext;
@@ -15,10 +15,10 @@ export declare class SlateStringComponent extends ViewContainerItem<SlateStringC
     isEmptyText(): boolean;
     isCompatibleString(): boolean;
     isVoid(): boolean;
-    getViewType(): import("@angular/core").TemplateRef<any> | typeof SlateDefaultStringComponent;
+    getViewType(): import("@angular/core").TemplateRef<any> | typeof SlateDefaultString;
     getType(): SlateStringContext['type'];
     getContext(): SlateStringContext;
     memoizedContext(prev: SlateStringContext, next: SlateStringContext): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SlateStringComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SlateStringComponent, "span[slateString]", never, { "context": "context"; }, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlateString, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlateString, "span[slateString]", never, { "context": { "alias": "context"; "required": false; }; }, {}, never, never, true, never>;
 }

package/components/string/template.component.d.ts

@@ -1,9 +1,9 @@
 import { TemplateRef } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare class SlateStringTemplateComponent {
+export declare class SlateStringTemplate {
     compatibleStringTemplate: TemplateRef<any>;
     voidStringTemplate: TemplateRef<any>;
     emptyTextTemplate: TemplateRef<any>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SlateStringTemplateComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SlateStringTemplateComponent, "slate-string-template", never, {}, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlateStringTemplate, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlateStringTemplate, "slate-string-template", never, {}, {}, never, never, true, never>;
 }

package/components/text/default-text.component.d.ts

@@ -1,6 +1,6 @@
 import { BaseTextComponent } from '../../view/base';
 import * as i0 from "@angular/core";
-export declare class SlateDefaultTextComponent extends BaseTextComponent {
-    static ɵfac: i0.ɵɵFactoryDeclaration<SlateDefaultTextComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SlateDefaultTextComponent, "span[slateDefaultText]", never, {}, {}, never, never, false, never>;
+export declare class SlateDefaultText extends BaseTextComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlateDefaultText, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlateDefaultText, "span[slateDefaultText]", never, {}, {}, never, never, true, never>;
 }

package/components/text/void-text.component.d.ts

@@ -1,10 +1,10 @@
 import { OnInit, OnChanges } from '@angular/core';
 import { BaseTextComponent } from '../../view/base';
 import * as i0 from "@angular/core";
-export declare class SlateVoidTextComponent extends BaseTextComponent implements OnInit, OnChanges {
+export declare class SlateVoidText extends BaseTextComponent implements OnInit, OnChanges {
     isLeafBlock: boolean;
     ngOnInit(): void;
     ngOnChanges(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SlateVoidTextComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SlateVoidTextComponent, "span[slateVoidText]", never, {}, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlateVoidText, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlateVoidText, "span[slateVoidText]", never, {}, {}, never, never, true, never>;
 }

package/esm2022/components/block-card/block-card.component.mjs

@@ -0,0 +1,33 @@
+import { Component, ViewChild } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SlateBlockCard {
+    get nativeElement() {
+        return this.elementRef.nativeElement;
+    }
+    get centerContainerElement() {
+        return this.centerContianer.nativeElement;
+    }
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+    }
+    ngOnInit() {
+        this.append();
+        this.nativeElement.classList.add(`slate-block-card`);
+    }
+    append() {
+        this.centerRootNodes.forEach(rootNode => !this.centerContainerElement.contains(rootNode) && this.centerContainerElement.appendChild(rootNode));
+    }
+    initializeCenter(rootNodes) {
+        this.centerRootNodes = rootNodes;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: SlateBlockCard, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.1", type: SlateBlockCard, isStandalone: true, selector: "slate-block-card, [slateBlockCard]", viewQueries: [{ propertyName: "centerContianer", first: true, predicate: ["centerContianer"], descendants: true, static: true }], ngImport: i0, template: "<span card-target=\"card-left\" class=\"card-left\">{{ '\\uFEFF' }}</span>\n<div card-target=\"card-center\" #centerContianer></div>\n<span card-target=\"card-right\" class=\"card-right\">{{ '\\uFEFF' }}</span>\n" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: SlateBlockCard, decorators: [{
+            type: Component,
+            args: [{ selector: 'slate-block-card, [slateBlockCard]', standalone: true, template: "<span card-target=\"card-left\" class=\"card-left\">{{ '\\uFEFF' }}</span>\n<div card-target=\"card-center\" #centerContianer></div>\n<span card-target=\"card-right\" class=\"card-right\">{{ '\\uFEFF' }}</span>\n" }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { centerContianer: [{
+                type: ViewChild,
+                args: ['centerContianer', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/children/children.component.mjs

@@ -0,0 +1,51 @@
+import { ChangeDetectionStrategy, Component, Input, ViewChildren } from '@angular/core';
+import { SlateDescendant } from '../descendant/descendant.component';
+import { AngularEditor } from '../../plugins/angular-editor';
+import { ViewContainer } from '../../view/container';
+import { NgFor } from '@angular/common';
+import * as i0 from "@angular/core";
+export class SlateChildren extends ViewContainer {
+    constructor() {
+        super(...arguments);
+        this.trackBy = (index, node) => {
+            return this.viewContext.trackBy(node) || AngularEditor.findKey(this.viewContext.editor, node);
+        };
+    }
+    ngOnInit() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: SlateChildren, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.1", type: SlateChildren, isStandalone: true, selector: "slate-children", inputs: { children: "children", context: "context", viewContext: "viewContext" }, viewQueries: [{ propertyName: "childrenComponent", predicate: SlateDescendant, descendants: true, read: SlateDescendant }], usesInheritance: true, ngImport: i0, template: `<slate-descendant
+        [descendant]="descendant"
+        [context]="context"
+        [viewContext]="viewContext"
+        [viewContext]="viewContext"
+        [index]="index"
+        *ngFor="let descendant of children; let index = index; trackBy: trackBy"
+    ></slate-descendant>`, isInline: true, dependencies: [{ kind: "directive", type: NgFor, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: SlateDescendant, selector: "slate-descendant", inputs: ["descendant", "context", "viewContext", "index"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: SlateChildren, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'slate-children',
+                    template: `<slate-descendant
+        [descendant]="descendant"
+        [context]="context"
+        [viewContext]="viewContext"
+        [viewContext]="viewContext"
+        [index]="index"
+        *ngFor="let descendant of children; let index = index; trackBy: trackBy"
+    ></slate-descendant>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    imports: [NgFor, SlateDescendant]
+                }]
+        }], propDecorators: { children: [{
+                type: Input
+            }], context: [{
+                type: Input
+            }], viewContext: [{
+                type: Input
+            }], childrenComponent: [{
+                type: ViewChildren,
+                args: [SlateDescendant, { read: SlateDescendant }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/descendant/descendant.component.mjs

@@ -0,0 +1,186 @@
+import { ChangeDetectionStrategy, Component, Inject, Input } from '@angular/core';
+import { SlateBlockCard } from '../block-card/block-card.component';
+import { ViewContainerItem } from '../../view/container-item';
+import { Editor, Range, Element } from 'slate';
+import { AngularEditor } from '../../plugins/angular-editor';
+import { NODE_TO_INDEX, NODE_TO_PARENT } from '../../utils/weak-maps';
+import { SlateDefaultText } from '../text/default-text.component';
+import { SlateVoidText } from '../text/void-text.component';
+import { isDecoratorRangeListEqual } from '../../utils';
+import { SlateErrorCode } from '../../types';
+import { SLATE_DEFAULT_ELEMENT_COMPONENT_TOKEN } from '../element/default-element.component.token';
+import * as i0 from "@angular/core";
+export class SlateDescendant extends ViewContainerItem {
+    get rootNodes() {
+        if (this.blockCardComponentRef) {
+            return [this.blockCardComponentRef.instance.nativeElement];
+        }
+        return super.getRootNodes();
+    }
+    get isBlockCard() {
+        return this.viewContext.editor.isBlockCard(this.descendant);
+    }
+    constructor(viewContainerRef, defaultElementComponentType) {
+        super(viewContainerRef);
+        this.viewContainerRef = viewContainerRef;
+        this.defaultElementComponentType = defaultElementComponentType;
+    }
+    ngOnInit() {
+        NODE_TO_INDEX.set(this.descendant, this.index);
+        NODE_TO_PARENT.set(this.descendant, this.context.parent);
+        this.createView();
+        if (this.isBlockCard) {
+            this.createBlockCard();
+        }
+    }
+    destroyView() {
+        super.destroyView();
+        this.destroyBlockCard();
+    }
+    ngOnChanges() {
+        if (!this.initialized) {
+            return;
+        }
+        NODE_TO_INDEX.set(this.descendant, this.index);
+        NODE_TO_PARENT.set(this.descendant, this.context.parent);
+        this.updateView();
+        if (this.isBlockCard) {
+            this.updateBlockCard();
+        }
+    }
+    destroyBlockCard() {
+        if (this.blockCardComponentRef) {
+            this.blockCardComponentRef.destroy();
+            this.blockCardComponentRef = null;
+        }
+    }
+    createBlockCard() {
+        const rootNodes = this.rootNodes;
+        this.blockCardComponentRef = this.viewContainerRef.createComponent(SlateBlockCard);
+        this.blockCardComponentRef.instance.initializeCenter(rootNodes);
+    }
+    updateBlockCard() {
+        if (this.blockCardComponentRef) {
+            return;
+        }
+        const rootNodes = this.rootNodes;
+        this.createBlockCard();
+        const firstRootNode = rootNodes[0];
+        firstRootNode.replaceWith(this.blockCardComponentRef.instance.nativeElement);
+    }
+    getCommonContext() {
+        const path = AngularEditor.findPath(this.viewContext.editor, this.context.parent);
+        const p = path.concat(this.index);
+        try {
+            const range = Editor.range(this.viewContext.editor, p);
+            const sel = this.context.selection && Range.intersection(range, this.context.selection);
+            const ds = this.context.decorate([this.descendant, p]);
+            for (const dec of this.context.decorations) {
+                const d = Range.intersection(dec, range);
+                if (d) {
+                    ds.push(d);
+                }
+            }
+            return { selection: sel, decorations: ds };
+        }
+        catch (error) {
+            this.viewContext.editor.onError({
+                code: SlateErrorCode.GetStartPointError,
+                nativeError: error
+            });
+            return { selection: null, decorations: [] };
+        }
+    }
+    getContext() {
+        if (Element.isElement(this.descendant)) {
+            const computedContext = this.getCommonContext();
+            const key = AngularEditor.findKey(this.viewContext.editor, this.descendant);
+            const isInline = this.viewContext.editor.isInline(this.descendant);
+            const isVoid = this.viewContext.editor.isVoid(this.descendant);
+            const elementContext = {
+                element: this.descendant,
+                ...computedContext,
+                attributes: {
+                    'data-slate-node': 'element',
+                    'data-slate-key': key.id
+                },
+                decorate: this.context.decorate,
+                readonly: this.context.readonly
+            };
+            if (isInline) {
+                elementContext.attributes['data-slate-inline'] = true;
+            }
+            if (isVoid) {
+                elementContext.attributes['data-slate-void'] = true;
+                elementContext.attributes.contenteditable = false;
+            }
+            return elementContext;
+        }
+        else {
+            const computedContext = this.getCommonContext();
+            const isLeafBlock = AngularEditor.isLeafBlock(this.viewContext.editor, this.context.parent);
+            const textContext = {
+                decorations: computedContext.decorations,
+                isLast: isLeafBlock && this.index === this.context.parent.children.length - 1,
+                parent: this.context.parent,
+                text: this.descendant
+            };
+            return textContext;
+        }
+    }
+    getViewType() {
+        if (Element.isElement(this.descendant)) {
+            return (this.viewContext.renderElement && this.viewContext.renderElement(this.descendant)) || this.defaultElementComponentType;
+        }
+        else {
+            const isVoid = this.viewContext.editor.isVoid(this.context.parent);
+            return isVoid
+                ? SlateVoidText
+                : (this.viewContext.renderText && this.viewContext.renderText(this.descendant)) || SlateDefaultText;
+        }
+    }
+    memoizedElementContext(prev, next) {
+        return (prev.element === next.element &&
+            (!this.viewContext.isStrictDecorate || prev.decorate === next.decorate) &&
+            prev.readonly === next.readonly &&
+            isDecoratorRangeListEqual(prev.decorations, next.decorations) &&
+            (prev.selection === next.selection || (!!prev.selection && !!next.selection && Range.equals(prev.selection, next.selection))));
+    }
+    memoizedTextContext(prev, next) {
+        return (next.parent === prev.parent &&
+            next.isLast === prev.isLast &&
+            next.text === prev.text &&
+            isDecoratorRangeListEqual(next.decorations, prev.decorations));
+    }
+    memoizedContext(prev, next) {
+        if (Element.isElement(this.descendant)) {
+            return this.memoizedElementContext(prev, next);
+        }
+        else {
+            return this.memoizedTextContext(prev, next);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: SlateDescendant, deps: [{ token: i0.ViewContainerRef }, { token: SLATE_DEFAULT_ELEMENT_COMPONENT_TOKEN }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.1", type: SlateDescendant, isStandalone: true, selector: "slate-descendant", inputs: { descendant: "descendant", context: "context", viewContext: "viewContext", index: "index" }, usesInheritance: true, usesOnChanges: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: SlateDescendant, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'slate-descendant',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [SLATE_DEFAULT_ELEMENT_COMPONENT_TOKEN]
+                }] }]; }, propDecorators: { descendant: [{
+                type: Input
+            }], context: [{
+                type: Input
+            }], viewContext: [{
+                type: Input
+            }], index: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"descendant.component.js","sourceRoot":"","sources":["../../../../packages/src/components/descendant/descendant.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, Inject, Input, OnChanges, OnInit, ViewContainerRef } from '@angular/core';\nimport { SlateBlockCard } from '../block-card/block-card.component';\nimport { ViewContainerItem } from '../../view/container-item';\nimport { Descendant, Editor, Range, Element } from 'slate';\nimport { SlateChildrenContext, SlateElementContext, SlateTextContext, SlateViewContext } from '../../view/context';\nimport { AngularEditor } from '../../plugins/angular-editor';\nimport { NODE_TO_INDEX, NODE_TO_PARENT } from '../../utils/weak-maps';\nimport { BaseElementComponent, BaseTextComponent } from '../../view/base';\nimport { SlateDefaultText } from '../text/default-text.component';\nimport { SlateVoidText } from '../text/void-text.component';\nimport { isDecoratorRangeListEqual } from '../../utils';\nimport { ComponentType, ViewType } from '../../types/view';\nimport { SlateErrorCode } from '../../types';\nimport { SLATE_DEFAULT_ELEMENT_COMPONENT_TOKEN } from '../element/default-element.component.token';\n\n@Component({\n    selector: 'slate-descendant',\n    template: '',\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    standalone: true\n})\nexport class SlateDescendant\n    extends ViewContainerItem<SlateElementContext | SlateTextContext, BaseElementComponent | BaseTextComponent>\n    implements OnInit, OnChanges\n{\n    @Input() descendant: Descendant;\n\n    @Input() context: SlateChildrenContext;\n\n    @Input() viewContext: SlateViewContext;\n\n    @Input() index: number;\n\n    get rootNodes(): HTMLElement[] {\n        if (this.blockCardComponentRef) {\n            return [this.blockCardComponentRef.instance.nativeElement];\n        }\n        return super.getRootNodes();\n    }\n\n    get isBlockCard() {\n        return this.viewContext.editor.isBlockCard(this.descendant);\n    }\n\n    constructor(\n        protected viewContainerRef: ViewContainerRef,\n        @Inject(SLATE_DEFAULT_ELEMENT_COMPONENT_TOKEN)\n        public defaultElementComponentType: ComponentType<BaseElementComponent>\n    ) {\n        super(viewContainerRef);\n    }\n\n    ngOnInit() {\n        NODE_TO_INDEX.set(this.descendant, this.index);\n        NODE_TO_PARENT.set(this.descendant, this.context.parent);\n        this.createView();\n        if (this.isBlockCard) {\n            this.createBlockCard();\n        }\n    }\n\n    destroyView() {\n        super.destroyView();\n        this.destroyBlockCard();\n    }\n\n    ngOnChanges() {\n        if (!this.initialized) {\n            return;\n        }\n        NODE_TO_INDEX.set(this.descendant, this.index);\n        NODE_TO_PARENT.set(this.descendant, this.context.parent);\n        this.updateView();\n        if (this.isBlockCard) {\n            this.updateBlockCard();\n        }\n    }\n\n    destroyBlockCard() {\n        if (this.blockCardComponentRef) {\n            this.blockCardComponentRef.destroy();\n            this.blockCardComponentRef = null;\n        }\n    }\n\n    createBlockCard() {\n        const rootNodes = this.rootNodes;\n        this.blockCardComponentRef = this.viewContainerRef.createComponent<SlateBlockCard>(SlateBlockCard);\n        this.blockCardComponentRef.instance.initializeCenter(rootNodes);\n    }\n\n    updateBlockCard() {\n        if (this.blockCardComponentRef) {\n            return;\n        }\n        const rootNodes = this.rootNodes;\n        this.createBlockCard();\n        const firstRootNode = rootNodes[0];\n        firstRootNode.replaceWith(this.blockCardComponentRef.instance.nativeElement);\n    }\n\n    getCommonContext(): { selection: Range; decorations: Range[] } {\n        const path = AngularEditor.findPath(this.viewContext.editor, this.context.parent);\n        const p = path.concat(this.index);\n        try {\n            const range = Editor.range(this.viewContext.editor, p);\n            const sel = this.context.selection && Range.intersection(range, this.context.selection);\n            const ds = this.context.decorate([this.descendant, p]);\n            for (const dec of this.context.decorations) {\n                const d = Range.intersection(dec, range);\n                if (d) {\n                    ds.push(d);\n                }\n            }\n            return { selection: sel, decorations: ds };\n        } catch (error) {\n            this.viewContext.editor.onError({\n                code: SlateErrorCode.GetStartPointError,\n                nativeError: error\n            });\n            return { selection: null, decorations: [] };\n        }\n    }\n\n    getContext(): SlateElementContext | SlateTextContext {\n        if (Element.isElement(this.descendant)) {\n            const computedContext = this.getCommonContext();\n            const key = AngularEditor.findKey(this.viewContext.editor, this.descendant);\n            const isInline = this.viewContext.editor.isInline(this.descendant);\n            const isVoid = this.viewContext.editor.isVoid(this.descendant);\n            const elementContext: SlateElementContext = {\n                element: this.descendant,\n                ...computedContext,\n                attributes: {\n                    'data-slate-node': 'element',\n                    'data-slate-key': key.id\n                },\n                decorate: this.context.decorate,\n                readonly: this.context.readonly\n            };\n            if (isInline) {\n                elementContext.attributes['data-slate-inline'] = true;\n            }\n            if (isVoid) {\n                elementContext.attributes['data-slate-void'] = true;\n                elementContext.attributes.contenteditable = false;\n            }\n            return elementContext;\n        } else {\n            const computedContext = this.getCommonContext();\n            const isLeafBlock = AngularEditor.isLeafBlock(this.viewContext.editor, this.context.parent);\n            const textContext: SlateTextContext = {\n                decorations: computedContext.decorations,\n                isLast: isLeafBlock && this.index === this.context.parent.children.length - 1,\n                parent: this.context.parent as Element,\n                text: this.descendant\n            };\n            return textContext;\n        }\n    }\n\n    getViewType(): ViewType {\n        if (Element.isElement(this.descendant)) {\n            return (this.viewContext.renderElement && this.viewContext.renderElement(this.descendant)) || this.defaultElementComponentType;\n        } else {\n            const isVoid = this.viewContext.editor.isVoid(this.context.parent as Element);\n            return isVoid\n                ? SlateVoidText\n                : (this.viewContext.renderText && this.viewContext.renderText(this.descendant)) || SlateDefaultText;\n        }\n    }\n\n    memoizedElementContext(prev: SlateElementContext, next: SlateElementContext) {\n        return (\n            prev.element === next.element &&\n            (!this.viewContext.isStrictDecorate || prev.decorate === next.decorate) &&\n            prev.readonly === next.readonly &&\n            isDecoratorRangeListEqual(prev.decorations, next.decorations) &&\n            (prev.selection === next.selection || (!!prev.selection && !!next.selection && Range.equals(prev.selection, next.selection)))\n        );\n    }\n\n    memoizedTextContext(prev: SlateTextContext, next: SlateTextContext) {\n        return (\n            next.parent === prev.parent &&\n            next.isLast === prev.isLast &&\n            next.text === prev.text &&\n            isDecoratorRangeListEqual(next.decorations, prev.decorations)\n        );\n    }\n\n    memoizedContext(prev: SlateElementContext | SlateTextContext, next: SlateElementContext | SlateTextContext): boolean {\n        if (Element.isElement(this.descendant)) {\n            return this.memoizedElementContext(prev as SlateElementContext, next as SlateElementContext);\n        } else {\n            return this.memoizedTextContext(prev as SlateTextContext, next as SlateTextContext);\n        }\n    }\n}\n"]}