@talrace/ngx-noder 0.0.2

package/lib/+shared/editor/core/layers/edges.layer.d.ts

@@ -0,0 +1,24 @@
+import { EdgeElementModel } from '../models/edge-element.model';
+import { EditorService } from '../../interaction/editor.service';
+import { EditSession } from '../edit.session';
+import { EventEmitting } from '../base/event-emitting';
+import { ILayerConfig } from '../interfaces/layer.config';
+import { PageType } from '../enums/page-type.enum';
+export declare class EdgesLayer extends EventEmitting {
+    private editorService;
+    element: HTMLElement;
+    session: EditSession;
+    config: ILayerConfig;
+    edgeElements: EdgeElementModel[];
+    constructor(parentElement: HTMLElement, editorService: EditorService);
+    destroy(): void;
+    setSession(newSession: EditSession): void;
+    update(config: ILayerConfig): void;
+    scrollPages(config: ILayerConfig): void;
+    updateByLocation(updatedPageType: PageType): void;
+    protected getParagraphTop(topOffset: number, page: number): number;
+    private renderPagesEdgeComponents;
+    private renderEdgeComponent;
+    private removeRenderedComponents;
+    private pagesCountChangedHandler;
+}

package/lib/+shared/editor/core/layers/lines.d.ts

@@ -0,0 +1,21 @@
+import { Cell } from '../interfaces/cell.interface';
+export declare class Lines {
+    element: HTMLElement;
+    cells: Cell[];
+    cellCache: Cell[];
+    get length(): number;
+    get last(): Cell;
+    get pageSize(): number;
+    private _pageSize;
+    get pagesCount(): number;
+    private _pagesCount;
+    constructor(element: HTMLElement);
+    shift(): void;
+    pop(): void;
+    push(data: Cell | Cell[]): void;
+    unshift(data: Cell | Cell[]): void;
+    cacheCell(cell: Cell): void;
+    createCell(row: number, page?: number): Cell;
+    setSizes(pagesCount: number, pageHeight: number): void;
+    private setContainerSize;
+}

package/lib/+shared/editor/core/layers/pages.layer.d.ts

@@ -0,0 +1,27 @@
+import { EditSession } from '../edit.session';
+import { EventEmitting } from '../base/event-emitting';
+import { ILayerConfig } from '../interfaces/layer.config';
+export declare class PagesLayer extends EventEmitting {
+    parentElement: HTMLElement;
+    element: HTMLElement;
+    session: EditSession;
+    pageBreakElements: HTMLElement[];
+    minPageNumber: number;
+    maxPageNumber: number;
+    rulerLeft: HTMLElement;
+    rulerRight: HTMLElement;
+    get pageSize(): number;
+    private _pageSize;
+    get pagesCount(): number;
+    private _pagesCount;
+    constructor(parentElement: HTMLElement);
+    update(config: ILayerConfig): void;
+    setSession(session: EditSession): void;
+    showRullerLines(positions: number[]): void;
+    destroy(): void;
+    protected getPageSpace(): number;
+    private removePages;
+    private addPages;
+    private setContainerSize;
+    private pagesCountChangedHandler;
+}

package/lib/+shared/editor/core/layers/print.edges.layer.d.ts

@@ -0,0 +1,4 @@
+import { EdgesLayer } from './edges.layer';
+export declare class PrintEdgesLayer extends EdgesLayer {
+    getParagraphTop(topOffset: number, page: number): number;
+}

package/lib/+shared/editor/core/layers/print.pages.layer.d.ts

@@ -0,0 +1,4 @@
+import { PagesLayer } from './pages.layer';
+export declare class PrintPagesLayer extends PagesLayer {
+    getPageSpace(): number;
+}

package/lib/+shared/editor/core/layers/print.text.layer.d.ts

@@ -0,0 +1,5 @@
+import { Paragraph } from '../paging/paragraph';
+import { TextLayer } from './text.layer';
+export declare class PrintTextLayer extends TextLayer {
+    getParagraphTop(paragraphs: Paragraph[], row: number): number;
+}

package/lib/+shared/editor/core/layers/renderloop.d.ts

@@ -0,0 +1,8 @@
+import { IRenderChanges } from '../interfaces/render-changes.interface';
+import { RenderChangesModel } from '../models/render-changes.model';
+export declare class RenderLoop {
+    private readonly flush;
+    private changes;
+    constructor(onRender: (changes: RenderChangesModel) => void);
+    schedule(changes?: IRenderChanges): void;
+}

package/lib/+shared/editor/core/layers/scrollbar.d.ts

@@ -0,0 +1,41 @@
+import { EventEmitting } from '../base/event-emitting';
+/**
+ * Represents a vertical scroll bar.
+ * @class ScrollBar
+ **/
+export declare class ScrollBar extends EventEmitting {
+    private parent;
+    readonly MAX_SCROLL_H = 32768;
+    element: HTMLElement;
+    inner: HTMLElement;
+    isVisible: boolean;
+    scrollTop: number;
+    private skipEvent;
+    private coeff;
+    /**
+     * Sets the scroll height of the scroll bar, in pixels.
+     **/
+    set scrollHeight(value: number);
+    get scrollHeight(): number;
+    private _scrollHeight;
+    /**
+     * Sets the height of the scroll bar, in pixels.
+     **/
+    set height(value: number);
+    /**
+     * Returns the width of the scroll bar.
+     **/
+    get width(): number;
+    private _width;
+    constructor(parent: HTMLElement);
+    /**
+     * Emitted when the scroll bar, well, scrolls.
+     **/
+    onScroll: () => void;
+    setVisible(isVisible: boolean): void;
+    /**
+     * Sets the scroll top of the scroll bar.
+     **/
+    setScrollTop(value: number): void;
+    private init;
+}

package/lib/+shared/editor/core/layers/selection.layer.d.ts

@@ -0,0 +1,19 @@
+import { EditSession } from '../edit.session';
+import { ILayerConfig } from '../interfaces/layer.config';
+import { Range } from '../range';
+export declare class SelectionLayer {
+    element: HTMLElement;
+    session: EditSession;
+    marker: Range | null;
+    selectionIndex: number;
+    config: ILayerConfig;
+    constructor(parentEl: HTMLElement, cssClass: string);
+    setSession(session: EditSession): void;
+    renderSelection(css: string): void;
+    update(config: ILayerConfig): void;
+    getTop(row: number): number;
+    drawMultiLineMarker(range: Range): void;
+    drawSingleLineMarker(range: Range): void;
+    private getRangeInfo;
+    private getMarkerStyle;
+}

package/lib/+shared/editor/core/layers/text.layer.d.ts

@@ -0,0 +1,22 @@
+import { EditSession } from '../edit.session';
+import { EventEmitting } from '../base/event-emitting';
+import { ILayerConfig } from '../interfaces/layer.config';
+import { Lines } from './lines';
+import { Paragraph } from '../paging/paragraph';
+import { RenderingHelper } from '../helpers/rendering.helper';
+export declare class TextLayer extends EventEmitting {
+    private renderingHelper;
+    element: HTMLElement;
+    lines: Lines;
+    session: EditSession;
+    config: ILayerConfig;
+    constructor(parentElement: HTMLElement, renderingHelper?: typeof RenderingHelper);
+    setSession(session: EditSession): void;
+    update(config: ILayerConfig): void;
+    scrollLines(config: ILayerConfig): void;
+    destroy(): void;
+    protected getParagraphTop(paragraphs: Paragraph[], row: number): number;
+    private renderTextParagraph;
+    private renderTextLines;
+    private pagesCountChangedHandler;
+}

package/lib/+shared/editor/core/models/display-token.model.d.ts

@@ -0,0 +1,27 @@
+import { IFontMetricSize } from '../interfaces/font-metric-size.interface';
+export declare class DisplayToken implements IFontMetricSize {
+    width: number;
+    height: number;
+    baseline: number;
+    content: number;
+    font: number;
+    line: number;
+    lineSpacing: number;
+    multiplier: number;
+    ascent: number;
+    descent: number;
+    displayValue: number;
+    align: number;
+    indentFirstLine: number;
+    indentHanging: number;
+    indentLeft: number;
+    indentRight: number;
+    indentBefore: number;
+    indentAfter: number;
+    isPageBreak: boolean;
+    isLineBreak: boolean;
+    isTab: boolean;
+    isTable: boolean;
+    get breaksLine(): boolean;
+    constructor(fields?: Partial<DisplayToken>);
+}

package/lib/+shared/editor/core/models/distance.model.d.ts

@@ -0,0 +1,6 @@
+export declare class DistanceModel {
+    end: number;
+    selectionEnd: number;
+    start: number;
+    constructor(fields?: Partial<DistanceModel>);
+}

package/lib/+shared/editor/core/models/edge-element.model.d.ts

@@ -0,0 +1,7 @@
+import { PageType } from '../enums/page-type.enum';
+export declare class EdgeElementModel {
+    element: HTMLElement;
+    page: number;
+    pageType: PageType;
+    constructor(fields?: Partial<EdgeElementModel>);
+}

package/lib/+shared/editor/core/models/format-ext.model.d.ts

@@ -0,0 +1,5 @@
+import { FormatModel } from '../../../../models/generated/format.model';
+export declare class FormatExtModel extends FormatModel {
+    content: string;
+    constructor(fields?: Partial<FormatExtModel>);
+}

package/lib/+shared/editor/core/models/indent.model.d.ts

@@ -0,0 +1,7 @@
+export declare class IndentModel {
+    firstLine: number;
+    hanging: number;
+    left: number;
+    right: number;
+    constructor(firstLine: number, hanging: number, left: number, right: number);
+}

package/lib/+shared/editor/core/models/line-info.model.d.ts

@@ -0,0 +1,14 @@
+import { IndentModel } from './indent.model';
+export declare class LineInfoModel {
+    height: number;
+    width: number;
+    align: number;
+    indent: IndentModel;
+    offsetBefore: number;
+    offsetAfter: number;
+    lineSpacing: number;
+    isAfterPageBreak: boolean;
+    isEndedByPageBreak: boolean;
+    backgroundColor: string;
+    constructor(fields?: Partial<LineInfoModel>);
+}

package/lib/+shared/editor/core/models/margin.model.d.ts

@@ -0,0 +1,9 @@
+export declare class MarginModel {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    header: number;
+    footer: number;
+    constructor(fields?: Partial<MarginModel>);
+}

package/lib/+shared/editor/core/models/numbering-data.model.d.ts

@@ -0,0 +1,11 @@
+import { TextStyleModel } from '../../../../models/generated/text-style.model';
+export declare class NumberingDataModel {
+    numberingId: number;
+    level: number;
+    marker: string;
+    markerTextStyle: TextStyleModel;
+    height: number;
+    width: number;
+    paddingLeft: number;
+    constructor(fields?: Partial<NumberingDataModel>);
+}

package/lib/+shared/editor/core/models/render-changes.model.d.ts

@@ -0,0 +1,14 @@
+import { IRenderChanges } from '../interfaces/render-changes.interface';
+export declare class RenderChangesModel implements IRenderChanges {
+    cursor: boolean;
+    full: boolean;
+    lines: boolean;
+    marker: boolean;
+    selection: boolean;
+    scroll: boolean;
+    size: boolean;
+    text: boolean;
+    get any(): boolean;
+    constructor(fields?: Partial<RenderChangesModel>);
+    apply(changes: IRenderChanges): void;
+}

package/lib/+shared/editor/core/paging/page-vertical-data.model.d.ts

@@ -0,0 +1,8 @@
+import { PageType } from '../enums/page-type.enum';
+export declare class PageVerticalDataModel {
+    marginBottom: number;
+    marginTop: number;
+    contentHeight: number;
+    pageType: PageType;
+    constructor(fields?: Partial<PageVerticalDataModel>);
+}

package/lib/+shared/editor/core/paging/pages.wrap.d.ts

@@ -0,0 +1,41 @@
+import { DisplayToken } from '../models/display-token.model';
+import { Edges } from '../components/edges/edges';
+import { EdgeType } from '../components/edges/edge-type.enum';
+import { EventEmitting } from '../base/event-emitting';
+import { LineInfoModel } from '../models/line-info.model';
+import { MarginModel } from '../models/margin.model';
+import { NumberingModel } from '../../../../models/generated/numbering.model';
+import { PageVerticalDataModel } from './page-vertical-data.model';
+import { Paragraph } from './paragraph';
+import { ParagraphModel } from '../../../../models/generated/paragraph.model';
+import { VisibleRange } from '../interfaces/visible-range.interface';
+export declare class PagesWrap extends EventEmitting {
+    pagesSpace: number;
+    documentMargin: MarginModel;
+    pageWidth: number;
+    pageHeight: number;
+    edges: Edges | null;
+    contentWidth: number;
+    allPagesHeight: number;
+    minHeight: number;
+    paragraphs: Paragraph[];
+    tabTokens: DisplayToken[];
+    pagesVerticalData: PageVerticalDataModel[];
+    get defaultVerticalData(): PageVerticalDataModel;
+    private processTextLinesProperties;
+    constructor(pagesSpace: number, documentMargin: MarginModel, pageWidth: number, pageHeight?: number, edges?: Edges | null);
+    getParagraphTop(paragraphs: Paragraph[], index: number): number;
+    getParagraphTopForPrint(paragraphs: Paragraph[], index: number, pagesSpace: number): number;
+    getParagraphHeight(paragraphs: Paragraph[], index: number): number;
+    remove(index: number, length: number): void;
+    reset(paragraphsLength: number): void;
+    set(row: number, lineInfos: LineInfoModel[], numberings: NumberingModel[], docParagraphs: ParagraphModel[]): void;
+    getVisibleRange(offsetTop: number, scrollerHeight: number): VisibleRange;
+    processParagraphsProperties(startParagraphIndex: number): void;
+    getAllParagraphsHeight(): number;
+    destroy(): void;
+    updatePageVerticalData(edgeType: EdgeType, page: number): void;
+    private getPreviousParagraphInfo;
+    private getVisiblePages;
+    private initPagesVerticalData;
+}

package/lib/+shared/editor/core/paging/paragraph.d.ts

@@ -0,0 +1,44 @@
+import { LineInfoModel } from '../models/line-info.model';
+import { NumberingDataModel } from '../models/numbering-data.model';
+import { PageVerticalDataModel } from './page-vertical-data.model';
+import { TextLineInfo } from './text-line-info';
+export declare class Paragraph {
+    numberingData: NumberingDataModel;
+    private offsetBefore;
+    private processTextLinesProperties;
+    textLinesInfo: TextLineInfo[];
+    pagePreviousContentHeight: number;
+    width: number;
+    height: number;
+    distanceFromTop: number;
+    pageNumbers: number[];
+    get firstPageNumber(): number;
+    get lastPageNumber(): number;
+    get firstScreenLine(): number;
+    get lastScreenLine(): number;
+    get isEndedByPageBreak(): boolean;
+    get backgroundColor(): string;
+    constructor(numberingData: NumberingDataModel, offsetBefore: number, processTextLinesProperties: (currentParagraph: Paragraph, prevParagraphInfo: {
+        lastPage: number;
+        paragraphHeight: number;
+        paragraphLastLine: number;
+    }, pagesInfo: {
+        pagesVerticalData: PageVerticalDataModel[];
+        pagesSpace: number;
+    }) => void);
+    setTextLinesInfo(linesInfos: LineInfoModel[]): void;
+    setIsAfterPageBreak(value: boolean): void;
+    getParagraphData(): {
+        lastPage: number;
+        paragraphHeight: number;
+        paragraphLastLine: number;
+    };
+    processParagraphProperties(prevParagraphInfo: {
+        lastPage: number;
+        paragraphHeight: number;
+        paragraphLastLine: number;
+    }, pagesInfo: {
+        pagesVerticalData: PageVerticalDataModel[];
+        pagesSpace: number;
+    }): void;
+}

package/lib/+shared/editor/core/paging/text-line-info.d.ts

@@ -0,0 +1,17 @@
+import { IndentModel } from '../models/indent.model';
+import { LineInfoModel } from '../models/line-info.model';
+export declare class TextLineInfo {
+    width: number;
+    height: number;
+    page?: number;
+    paddingLeft: number;
+    offsetBefore: number;
+    offsetAfter: number;
+    firstLinePageOffset: number;
+    endPageOffset: number;
+    screenLine: number;
+    isAfterPageBreak: boolean;
+    isEndedByPageBreak: boolean;
+    backgroundColor: string;
+    constructor(contentWidth: number, align: number, indent: IndentModel, fields?: Partial<LineInfoModel>);
+}

package/lib/+shared/editor/core/point.d.ts

@@ -0,0 +1,7 @@
+export declare class Point {
+    row: number;
+    column: number;
+    constructor(row: number, column: number);
+    static comparePoints(first: Point, second: Point): number;
+    static clone(point: Point): Point;
+}

package/lib/+shared/editor/core/print.renderer.d.ts

@@ -0,0 +1,25 @@
+import { EdgesLayer } from './layers/edges.layer';
+import { EditorService } from '../interaction/editor.service';
+import { EditSession } from './edit.session';
+import { PagesLayer } from './layers/pages.layer';
+import { PagesWrap } from './paging/pages.wrap';
+import { TextLayer } from './layers/text.layer';
+export declare class PrintRenderer {
+    private session;
+    content: HTMLElement;
+    edgesLayer: EdgesLayer;
+    textLayer: TextLayer;
+    pagesLayer: PagesLayer;
+    originalPagesWrap: PagesWrap;
+    documentHtml: string;
+    headHtml: string;
+    pagesCount: number;
+    constructor(session: EditSession, editorService: EditorService);
+    renderPrintDocument(): void;
+    private computeLayerConfig;
+    private createContent;
+    private createLayers;
+    private createDocumentHtml;
+    private createHeadWithStyles;
+    private getPrintPageStyle;
+}

package/lib/+shared/editor/core/range.d.ts

@@ -0,0 +1,32 @@
+import { EditSession } from './edit.session';
+import { Point } from './point';
+export declare class Range {
+    start: Point;
+    end: Point;
+    cursor: Point;
+    get isEmpty(): boolean;
+    get isSingleLine(): boolean;
+    constructor(start: Point, end: Point);
+    isEqual(range: Range | {
+        start: Point;
+        end: Point;
+    }): boolean;
+    contains(point: Point): boolean;
+    comparePoint(point: Point): number;
+    /**
+     * Given the current `Range`,
+     * this function converts those starting and ending points into screen positions, and then returns a new `Range` object.
+     * @param {EditSession} session The `EditSession` to retrieve coordinates from
+     * @returns {Range}
+     **/
+    toScreenRange(session: EditSession): Range;
+    /**
+     * Returns the part of the current `Range` that occurs within the boundaries of `firstRow` and `lastRow` as a new `Range` object.
+     * @param {Number} firstRow The starting row
+     * @param {Number} lastRow The ending row
+     * @returns {Range}
+     **/
+    clipRows(firstRow: number, lastRow: number): Range;
+    private compareSingleLine;
+    private compareMultiLine;
+}

package/lib/+shared/editor/core/renderer.d.ts

@@ -0,0 +1,60 @@
+import { CursorLayer } from './layers/cursor.layer';
+import { EditorService } from '../interaction/editor.service';
+import { EditSession } from './edit.session';
+import { EventEmitting } from './base/event-emitting';
+import { ILayerConfig } from './interfaces/layer.config';
+import { Point } from './point';
+import { Range } from './range';
+import { RenderChangesModel } from './models/render-changes.model';
+import { RenderLoop } from './layers/renderloop';
+import { SelectionLayer } from './layers/selection.layer';
+import { TextLayer } from './layers/text.layer';
+export declare class Renderer extends EventEmitting {
+    private editorService;
+    isMousePressed: boolean;
+    container: HTMLElement;
+    content: HTMLElement;
+    cursorLayer: CursorLayer;
+    textLayer: TextLayer;
+    selectionLayer: SelectionLayer;
+    session: EditSession;
+    loop: RenderLoop;
+    textarea: HTMLElement;
+    layerConfig: ILayerConfig;
+    changes: RenderChangesModel;
+    readonly textareaSize: {
+        height: number;
+        width: number;
+    };
+    constructor(parentContainer: HTMLElement, editorService: EditorService);
+    renderChanges(changes: RenderChangesModel, force?: boolean): void;
+    /**
+     * Triggers a partial update of the text, from the range given by the two parameters.
+     **/
+    updateLines(firstRow: number, lastRow: number): void;
+    moveTextAreaToCursor(): void;
+    setSession(session: EditSession): void;
+    updateSelection(range: Range): void;
+    /**
+     * Triggers a full update of the text, for all the rows.
+     **/
+    updateText(): void;
+    /**
+     * Triggers a full update of all the layers, for all the rows.
+     **/
+    updateFull(force?: boolean): void;
+    updateCursor(): void;
+    screenToTextCoordinates(x: number, y: number): Point;
+    showCursor(): void;
+    hideCursor(): void;
+    destroy(): void;
+    renderFull(): void;
+    renderText(): void;
+    renderCursor(): void;
+    renderSelection(): void;
+    private computeLayerConfig;
+    private pagesCountChangedHandler;
+    private createContentContainer;
+    private createLayers;
+    private createRenderLoop;
+}

package/lib/+shared/editor/core/search.d.ts

@@ -0,0 +1,32 @@
+import { EditSession } from './edit.session';
+import { Point } from './point';
+import { Range } from './range';
+export declare class SearchOptions {
+    term?: string;
+    backwards?: boolean;
+    start?: Point | Range;
+    skipCurrent?: boolean;
+    wrap?: boolean;
+    isMultiLine?: boolean;
+    regex?: RegExp | (RegExp[] & {
+        offset?: number;
+    });
+}
+export declare class Search {
+    options: SearchOptions;
+    forEach: (callback: any) => void;
+    forEachInLine: (row: number, offset: number, callback: any) => boolean;
+    constructor();
+    set(options: SearchOptions): void;
+    find(session: EditSession): Range;
+    assembleRegExp(options: SearchOptions): RegExp | RegExp[];
+    assembleMultilineRegExp(needle: string, modifier: string): RegExp[];
+    setMatchIterator(session: EditSession, options: SearchOptions): void;
+    private setForEach;
+    private setDefaultForEach;
+    private setForEachForBackwards;
+    private setForEachInLine;
+    private setForEachInLineForRegArray;
+    private setForEachInLineForBackwards;
+    private setDefaultForEachInLine;
+}