archiyou 0.7.0

package/dist/src/Doc.d.ts

@@ -0,0 +1,181 @@
+import { ArchiyouApp, AnyShapeOrCollection, PageSide, PageOrientation, ContainerSide, ContainerSizeRelativeTo, ScaleInput, ImageOptions, TextOptions, Brep, ShapeCollection, Container, DocDocument, Page, PageSize, AnyPageContainer, TableContainerOptions, DocPathStyle, ContainerAlignment, ContainerHAlignment, ContainerVAlignment, ContainerPositionLike, DocPDFExporter, DocSettings, DocUnits, DocUnitsWithPerc, PercentageString, ValueWithUnitsString, WidthHeightInput, ContainerTableInput, DocData, DocGraphicInputRect, DocGraphicInputCircle, DocGraphicInputOrthoLine, ContainerBlock, TitleBlockInput, LabelBlockOptions } from './internal';
+export declare class Doc {
+    DOC_DEFAULT_NAME: string;
+    DOC_UNITS_DEFAULT: DocUnits;
+    PAGE_SIZE_DEFAULT: PageSize;
+    PAGE_ORIENTATION_DEFAULT: PageOrientation;
+    CONTENT_ALIGN_DEFAULT: ContainerAlignment;
+    TEXT_SIZE_DEFAULT: string;
+    TYPES_WITHOUT_CAPTION: string[];
+    _ay: ArchiyouApp;
+    _settings: DocSettings;
+    _brep: Brep;
+    _calc: any;
+    _pdfExporter: DocPDFExporter;
+    _docs: Array<DocDocument>;
+    _activeDoc: DocDocument;
+    _lastBlock: ContainerBlock;
+    _activePage: Page;
+    _activeContainer: AnyPageContainer;
+    _assetsCache: Record<string, any>;
+    constructor(settings?: DocSettings, ay?: ArchiyouApp);
+    hasDocs(): boolean;
+    setArchiyou(ay?: ArchiyouApp): void;
+    /** Reset state of Doc instance */
+    reset(): void;
+    _setDefaults(): Doc;
+    /** Execute pipeline for docs in worker scope
+     *  @param include list of docs to include (if empty all)
+     *  @param exclude list of docs to include (if empty exclude none)
+     *
+     *  NOTE: this is pretty black magic. We should give more structure to Workers, execution and scopes.
+    */
+    executePipelines(include?: Array<string>, exclude?: Array<string>): void;
+    /** Make a new DocDocument with optionally a name */
+    create(name?: string): Doc;
+    /** Set name of current document (might be the default) */
+    name(name: string): Doc;
+    /** Check if there is an active DocDocument, otherwise create a default one */
+    checkAndMakeDefaultDoc(): DocDocument;
+    /** Check if there is an active Page, otherwise create a default one
+     *  This avoid errors when user forgets to create a page
+    */
+    _getOrMakeActivePage(): Page;
+    /** Set Unit for active DocDocument: 'mm','cm' or 'inch' */
+    units(units: DocUnits): Doc;
+    /** Set general page ISO size (A0,A4 etc) for current doc */
+    pageSize(size: PageSize): Doc;
+    /** Set general page ISO size (A0,A4 etc) for current doc */
+    pageOrientation(o: PageOrientation): Doc;
+    /** Add a new page to the doc with given name */
+    page(name: string): Doc;
+    /** Define script that is executed before active DocDocument is generated */
+    pipeline(fn: () => any): Doc;
+    /** Set size of active Page */
+    size(size: PageSize): Doc;
+    /** Set padding of active Page (width (left and right) and height (top and bottom))
+     *  Use relative width/height ([0-1]), number with percentage (5%) or number with real units ('1cm','0.5"')
+    */
+    padding(w: WidthHeightInput, h?: WidthHeightInput): Doc;
+    /** Set orientation ('landscape' or 'portrait') of active page */
+    orientation(o: PageOrientation): Doc;
+    /** Add View Container to active Page */
+    view(name?: string, shapes?: ShapeCollection): Doc;
+    /** Add Image Container to active Page */
+    image(url: string, options?: ImageOptions): Doc;
+    /** Add Text line to active Page */
+    text(text: string | number, options?: TextOptions): Doc;
+    /** Add multiline text area */
+    textarea(text: string | number, options?: TextOptions): Doc;
+    /** Add table to active Page
+     *  @param input name of Calc table
+     *
+    */
+    table(nameOrData: ContainerTableInput, options?: TableContainerOptions): Doc;
+    /** Draw rect graphic on current page
+     *  @param ?input { size (when width=height), width, height, round }
+     */
+    rect(input?: number | string | DocGraphicInputRect, style?: DocPathStyle): this;
+    /** Draw circle graphic on current page
+     *  @param input { size (=radius), radius }
+     */
+    circle(input?: number | string | DocGraphicInputCircle, style?: DocPathStyle): Doc;
+    /** Draw ortho (horizontal|vertical) line graphic on current page
+     *  @param input string (10mm), number (10, with default units, mm) or object with options
+     *  @param thickness strokeWidth
+     *  @param color
+     *
+     */
+    _oline(type: 'h' | 'v', input?: string | number | DocGraphicInputOrthoLine, thickness?: number | string, color?: string): Doc;
+    hline(input?: string | number | DocGraphicInputOrthoLine, thickness?: number | string, color?: string): Doc;
+    vline(input?: string | number | DocGraphicInputOrthoLine, thickness?: number | string, color?: string): Doc;
+    /** Place default title block
+     *  @param data:TitleBlockInput
+     */
+    titleblock(data?: TitleBlockInput): this;
+    _getParamSummary(): string;
+    _getMetricSummary(): string;
+    _formatMetricParamValue(v: string | number): string;
+    /** Get version in different contexts
+     *  In editor we use ScriptVersion->PublishScript instances
+     *  In compute worker PublishScript
+     */
+    _getVersion(): string;
+    /** Get version string like 'v1.0 at 10-20-2025 */
+    _getVersionSummary(): string;
+    _splitStringRecurse(strings: Array<string>, splitChars: Array<string>): Array<string>;
+    /** Create a block with one or more label and one or more texts
+     *  The first label/text pair fills half of the container
+     *  Used mostly for titleblock
+     */
+    labelblock(labels: string | Array<string>, texts: string | Array<string>, options?: LabelBlockOptions): this;
+    /** Get last created ContainerBlock */
+    lastBlock(): ContainerBlock;
+    /** Set Page width or Container width based if View is active */
+    width(n: WidthHeightInput): Doc;
+    /** Set Page width or View width based if View is active */
+    height(n: WidthHeightInput): Doc;
+    /** Set Position of active Container
+     *   @param x
+     *     - if 0 <= x <= 1 relative to page content area 0.5 center)
+     *     - if > 1 in default DocDocument units (mostly mm)
+     *     - Alignment: topleft, bottom(center)
+     *     - absolute with units ('10mm')
+     *     - or array [x,y]
+     *   @param y see x, but without array
+     */
+    position(x: number | ContainerPositionLike, y?: number | string): Doc;
+    /** Set Pivot of active Container
+    *   - relative to page content area (0.5,0.5 => center)
+    *   - ContainerAlignment: 'left', 'top'
+    *
+    *      NOTE: We won't allow offsets with units ('10mm')
+    */
+    pivot(x: number | ContainerPositionLike | string | Array<number | number>, y?: number): Doc;
+    /** Turn on border on active container with optional styling */
+    border(style?: DocPathStyle): Doc;
+    /** set contentAlign on active container */
+    contentAlign(align: ContainerHAlignment | ContainerVAlignment | ContainerAlignment): Doc;
+    /** Set caption on active container */
+    caption(s?: string): this;
+    title(s?: string): this;
+    /** Bind ShapeCollection to View: either a real reference or the name of a ShapeCollection after running the doc pipeline */
+    shapes(shapes: AnyShapeOrCollection | string, all?: boolean): Doc;
+    zoom(level: number): Doc;
+    scale(factor?: ScaleInput): Doc;
+    /** Return names of docs present */
+    docs(): Array<string>;
+    getDoc(name: string): DocDocument | null;
+    getDocs(only?: Array<string> | any): Array<DocDocument>;
+    /** For moving Doc internally around from component scopes */
+    toInternalData(): Array<DocDocument>;
+    /** Export pure data */
+    toData(onlyDocs: string | Array<string>, noCache?: boolean): Promise<{
+        [key: string]: DocData;
+    } | undefined>;
+    /** Export selected or all DocDocuments to pdfs
+     *  @param only string/Array of doc names to export. Default is all
+     *  @returns Either single pdf ArrayBuffer or Record of ArrayBuffers if multiple docs are exported
+     */
+    toPDF(only?: string | Array<string>): Promise<ArrayBuffer | Record<string, ArrayBuffer>>;
+    /** Convenience save documents in Doc module directly to PDF file */
+    save(filename?: string): Promise<void>;
+    _units(): DocUnits;
+    _generateContainerName(containerOrName: string | Container): string;
+    _checkPageIsActive(): boolean;
+    /** Transform WidthHeightInput to relative width/height */
+    _resolveWidthHeightInput(n: WidthHeightInput, page: Page, side: ContainerSide): [number, ContainerSizeRelativeTo];
+    /** Percentage of page space, page minus page-padding (not entire padding) */
+    _resolvePercentageString(s: PercentageString): number;
+    /** Return width or height in relative coords of current Page and DocDocument units */
+    _resolveValueWithUnitsStringToRel(s: ValueWithUnitsString, page: Page, side: PageSide): number;
+    /** Split given string like 10mm to number and unit and do some checking
+     *     NOTE: We handle relative numbers ([0-1]) here too, in that case
+    */
+    _splitInputNumberUnits(s: string | number): [number, DocUnitsWithPerc] | null;
+    parseInputNumberUnitsConvertTo(n: string | number, unit: DocUnitsWithPerc): number | null;
+    /** Merge incoming DocDocument instances with current document
+     *  @d single or collection of DocDocument instance
+    */
+    merge(d: DocDocument | Array<DocDocument> | Record<string, DocDocument>, namePrefix?: string): this;
+}

package/dist/src/DocDocument.d.ts

@@ -0,0 +1,27 @@
+import { Doc, Page, DocUnits, PageSize, PageOrientation, DocPipeline, DocData } from './internal';
+/** A document that is part of a Doc module instance
+ *  It contains pages and some settings
+  */
+export declare class DocDocument {
+    DOC_DEFAULT_NAME: string;
+    DOC_UNITS_DEFAULT: DocUnits;
+    DOC_PAGE_SIZE_DEFAULT: PageSize;
+    DOC_PAGE_ORIENTATION_DEFAULT: PageOrientation;
+    name: string;
+    pageSize: PageSize;
+    pageOrientation: PageOrientation;
+    units: DocUnits;
+    _doc: Doc;
+    _pages: Array<Page>;
+    _pipelines: Array<DocPipeline>;
+    _activePage?: Page;
+    _component?: string;
+    constructor(doc: Doc, name: string);
+    /** Add page to this document */
+    createPage(name: string): Page;
+    pageExists(name: string): boolean;
+    addPipeline(p: DocPipeline): this;
+    toData(cache: Record<string, any> | undefined): Promise<DocData>;
+    /** Remove all references that tie this DocDocument instance to the execution scope */
+    resolveScopeReferences(): this;
+}

package/dist/src/DocPDFExporter.d.ts

@@ -0,0 +1,105 @@
+import { PageSize, PageData, ContainerData, DocData, DocPathStyle } from './internal';
+import { jsPDF } from 'jspdf';
+export declare class DocPDFExporter {
+    DEBUG: boolean;
+    TEXT_ALIGN_DEFAULT: string;
+    TEXT_BASELINE_DEFAULT: string;
+    TEXT_FONT_DEFAULT: string;
+    TABLE_FONTSIZE_DEFAULT: number;
+    TABLE_BORDER_THICKNESS_MM: number;
+    TABLE_PADDING_MM: number;
+    _autoTableModule: any;
+    inDocs: Record<string, DocData>;
+    docs: Record<string, jsPDF>;
+    blobs: Record<string, Blob>;
+    activeDoc: DocData;
+    activePage: PageData;
+    activePDFDoc: jsPDF;
+    _jsPDF: any;
+    _jsPDFDoc: any;
+    _hasJsPDF: boolean;
+    _jsdomNode: any;
+    /** Make DocPDFExporter instance either empty or with data and onDone function */
+    constructor(data?: DocData | Record<string, DocData>, onDone?: (buffers: Record<string, ArrayBuffer>) => any);
+    reset(): void;
+    export(data: DocData | Record<string, DocData>): Promise<Record<string, ArrayBuffer>>;
+    /** Load jsPDF as module dynamically */
+    loadJsPDF(): Promise<DocPDFExporter>;
+    handleFailedImport(e: any): void;
+    handleSuccesImport(): void;
+    hasJsPDF(): boolean;
+    run(data: DocData | Record<string, DocData>): Promise<Record<string, Blob>>;
+    /** Parse raw Doc data, either DocData or a set of documents in Record<string, DocData> */
+    parse(data?: DocData | Record<string, DocData>): Promise<Record<string, Blob>>;
+    /** Make a simple PDF test document directly with jspdf */
+    generateTestDoc(): Promise<void>;
+    /** Save the given doc (or the first) to file  */
+    _saveBlobToBrowserFile(docName?: string): Promise<void>;
+    /** Parse Doc data into PDFDocument */
+    _parseDoc(d: DocData): Promise<void>;
+    /** Set defaults of a JsPDF document */
+    setDocDefaults(d: jsPDF): void;
+    /** Wait until the active Doc stream is finished and place resulting Blob inside cache for later export */
+    _endActiveDoc(): Blob;
+    /** Get first Blob */
+    getBlob(): Blob | null;
+    _makePage(p: PageData): Promise<any>;
+    _placeContainer(c: ContainerData, p: PageData): Promise<void>;
+    /** Any elements for all Containers like border */
+    _placeContainerBasics(c: ContainerData, p: PageData): void;
+    /** Place text on activePDFDoc and active page */
+    _placeText(t: ContainerData, p: PageData): void;
+    /** Parse TextOptions to PDF text options, set basic styling directly on activePDFDoc and return parameters for specific creation function */
+    _setTextOptions(t: ContainerData, p: PageData): Record<string, any>;
+    /** First load the SVG or Bitmap image and then supply its buffer to jspdf */
+    _placeImage(img: ContainerData, p: PageData): Promise<void>;
+    /** Returns extension (without .) from url */
+    _getImageExt(url: string): string;
+    _getImageOptions(img: ContainerData, p: PageData): Record<string, any>;
+    /** Place View SVG on page
+     *
+     *      - view.content.data contains raw SVG string (<svg _bbox="..." _worldUnits='mm'><path .. >... )
+     *
+     *      - TODO:
+     *          * Implement protection against making drawings bigger than page, resulting in weird pages etc
+     *          * Implement view.zoomLevel, view.zoomRelativeTo etc. - NOW: only automatic filling of viewport/container
+     *
+     *
+    */
+    _placeViewSVG(view: ContainerData, p: PageData): void;
+    /** HACK: For some reason using this.activePDFDoc.path in _placeViewSVG()
+     *  does not apply drawing and styling to canvas. By drawing this bogus empty rectangle it does!
+     *  TODO: research why this works in code: https://github.com/parallax/jsPDF/blob/5d09af9135a2fe049c7d3c8b95df280d22e4a6db/src/jspdf.js#L4485
+      */
+    _drawFakePath(): void;
+    /** Set PDF styling before drawing anything */
+    _setPathStyle(style?: DocPathStyle): jsPDF;
+    /** Place table using jsPDF AutoTable
+     *  See: https://github.com/simonbengtsson/jsPDF-AutoTable
+     *  NOTE: We use a dynamic import for developer flexibility. If you want to use it: install it.
+    */
+    _placeTable(t: ContainerData, p: PageData): Promise<void>;
+    /** Place Graphic (hline, vline, rect, circle, etc) on active PDF page */
+    _placeGraphic(g: ContainerData, p: PageData): void;
+    isBrowser(): boolean;
+    isWorker(): boolean;
+    /** Convert relative page coordinate width to absolute PDF point coord of jsPDF system, also taking horizontal padding into account  */
+    coordRelWidthToPoints(a: number, page: PageData, transformWithPadding?: boolean): number;
+    /** Convert relative page coordinate height to absolute PDF point coord of jsPDF system,  also taking vertical padding into account */
+    coordRelHeightToPoints(a: number, page: PageData, transformWithPadding?: boolean): number;
+    /** Convert relative width (to page size or page-content) to points */
+    relWidthToPoints(a: number, page: PageData, withPadding?: boolean): number;
+    /** Convert relative height (to page size or page-content) to points */
+    relHeightToPoints(a: number, page: PageData, withPadding?: boolean): number;
+    pageHeightPoints(): number;
+    /** Convert Container position data to top left postion [x,y] in PDF points, including taking take of pivot position and Page.padding. In jspdf coord system
+     *      NOTES:
+     *          - All incoming ContainerData data (position, width, height) is relative to page size
+    */
+    containerToPDFPositionInPnts(c: ContainerData, p: PageData): Record<string, number>;
+    removeEmptyValueKeysObj(obj: Object): {};
+    _getNewFileHandle(desc: any, mime: any, ext: any, open?: boolean): Promise<any>;
+    _writeFile(fileHandle: any, contents: any): Promise<void>;
+    pageSizeToLowercase(s: PageSize): string;
+    getSVGPreserveAspectRatioOption(view?: ContainerData): string;
+}

package/dist/src/DocPage.d.ts

@@ -0,0 +1,75 @@
+import { Doc, DocDocument, PageSide, WidthHeightInput, PageData, DocUnits, PageSize, PageOrientation, AnyPageContainer, ValueWithUnitsString } from './internal';
+export declare class Page {
+    DEFAULT_PADDING: WidthHeightInput;
+    DEFAULT_SIZE: PageSize;
+    PAGE_ISO_SIZE_TO_WIDTH_HEIGHT_MM: {
+        A0: {
+            w: number;
+            h: number;
+        };
+        A1: {
+            w: number;
+            h: number;
+        };
+        A2: {
+            w: number;
+            h: number;
+        };
+        A3: {
+            w: number;
+            h: number;
+        };
+        A4: {
+            w: number;
+            h: number;
+        };
+        A5: {
+            w: number;
+            h: number;
+        };
+        A6: {
+            w: number;
+            h: number;
+        };
+        A7: {
+            w: number;
+            h: number;
+        };
+    };
+    name: string;
+    _doc: Doc;
+    _DocDocument: DocDocument;
+    _units: DocUnits;
+    _size: PageSize;
+    _width: number;
+    _height: number;
+    _orientation: PageOrientation;
+    _padding: Array<number>;
+    _containers: Array<AnyPageContainer>;
+    _variables: {
+        [key: string]: any;
+    };
+    constructor(doc: Doc, DocDocumentName: DocDocument, name: string);
+    /** Inherit settings from DocDocument and Doc parents */
+    setDefaultsFromDoc(): void;
+    setDefaults(): void;
+    size(size: PageSize): void;
+    /** Set width of Page in DocDocument units */
+    width(n: WidthHeightInput): Page;
+    /** Set height of Page in DocDocument units */
+    height(n: WidthHeightInput): Page;
+    orientation(): Page;
+    /** Set padding width (left and right) and height (top and bottom)
+     *  Use relative width/height ([0-1]), number with percentage (5%) or number with real units ('1cm','0.5"')
+    */
+    padding(w: WidthHeightInput, h?: WidthHeightInput): Page;
+    /** Add AnyPageContainer to page */
+    add(container: AnyPageContainer): void;
+    /** Transform numeric value with units to relative position to page width or height */
+    _resolveValueWithUnitsStringToRel(s: ValueWithUnitsString, side: PageSide): number;
+    toData(cache?: Record<string, any> | undefined): Promise<PageData>;
+    resolveScopeReferences(): this;
+    _containerExists(name: string): boolean;
+    /** Transform given ISO page size (A0-A7) to units in DocDocument units */
+    _sizeToWidthHeight(size: PageSize): void;
+}

package/dist/src/DocPageContainer.d.ts

@@ -0,0 +1,65 @@
+import { Page, WidthHeightInput, DocPathStyle, ContainerPositionRel, ContainerType, ContainerHAlignment, ContainerVAlignment, ContainerAlignment, ZoomRelativeTo, ScaleInput, ContainerSizeRelativeTo, ContainerPositionLike, ContainerData, Frame, ContainerPositionCoordAbs, ContainerPositionCoordRel, PageSide, ValueWithUnitsString } from './internal';
+export declare class Container {
+    WIDTH_DEFAULT: number;
+    HEIGHT_DEFAULT: number;
+    PIVOT_DEFAULT: ContainerAlignment;
+    POSITION_DEFAULT: ContainerAlignment;
+    CONTENT_ALIGN_DEFAULT: ContainerAlignment;
+    name: string;
+    _page: Page;
+    _parent: Container;
+    _type: ContainerType;
+    _width: number;
+    _height: number;
+    _widthRelativeTo: ContainerSizeRelativeTo;
+    _heightRelativeTo: ContainerSizeRelativeTo;
+    _position: Array<number | number>;
+    _pivot: Array<number | number>;
+    _border: boolean;
+    _borderStyle: DocPathStyle;
+    _frame: Frame;
+    _index: number;
+    _contentAlign: ContainerAlignment;
+    _content: any;
+    _zoomLevel: ScaleInput;
+    _zoomRelativeTo: ZoomRelativeTo;
+    _title: string;
+    _caption: string;
+    constructor();
+    _setDefaults(): void;
+    /** Options set after container is placed on page */
+    _onPlaced(i?: any): any;
+    on(page: Page): Container;
+    checkOnPage(): void;
+    setName(n: string): this;
+    /** Set width of this Container. Either in percentage of page area ([0-1]) or or units like 10mm, 20pnt */
+    width(n: WidthHeightInput): void;
+    /** Set height of this Container. Either in percentage of page area ([0-1]) or or units like 10mm, 20pnt */
+    height(n: WidthHeightInput): void;
+    /** Set position with a ContainerAlignment or percentage of width and height [x,y] or absolute position with units */
+    position(p: ContainerPositionLike): Container;
+    _setPositionCoord(c: ContainerPositionCoordAbs | ContainerPositionCoordRel, side: PageSide): number;
+    /** Set pivot with a ContainerAlignment ('top', 'topright') or percentage of width and height [x,y]  */
+    pivot(p: ContainerPositionLike): Container;
+    /** Set zoom level (which is relative to view container size) */
+    zoom(factor: number): void;
+    /** Set zoom level relative to world size of Shapes */
+    scale(factor: ScaleInput): void;
+    /** Turn on border on this container. Use without param to use default style */
+    border(style?: string | DocPathStyle): void;
+    caption(s: string): this;
+    title(s: string): this;
+    /** Transform from relative width (to page or page-content-area) to absolute (in DocUnits) */
+    _calculateAbsWidth(): number;
+    /** Transform from relative height (to page or page-content-area) to absolute (in DocUnits) */
+    _calculateAbsHeight(): number;
+    /** Alias for page._resolveValueWithUnitsStringToRel with active page (if any) */
+    _resolveValueWithUnitsStringToRel(s: ValueWithUnitsString, side: PageSide): number | null;
+    /** Export Data of Container */
+    toData(cache?: Record<string, any> | undefined): Promise<ContainerData>;
+    /** Output raw Container data */
+    _toContainerData(): ContainerData;
+    _containerHAlignmentToPositionRel(ax: ContainerHAlignment): number;
+    _containerVAlignmentToPositionRel(ay: ContainerVAlignment): number;
+    _containerAlignmentToPosition(a: ContainerAlignment): ContainerPositionRel;
+}

package/dist/src/DocPageContainerGraphic.d.ts

@@ -0,0 +1,10 @@
+import { Container, ContainerData, DocUnits, DocGraphicType, DocGraphicInputBase, DocGraphicInputRect, DocGraphicInputCircle, DocGraphicInputLine } from './internal';
+export declare class GraphicContainer extends Container {
+    DEFAULT_GRAPHIC_UNITS: DocUnits;
+    DEFAULT_GRAPHIC_PIVOT: number[];
+    _options: DocGraphicInputBase | DocGraphicInputRect | DocGraphicInputCircle | DocGraphicInputLine;
+    constructor(type: DocGraphicType, input: DocGraphicInputBase | DocGraphicInputRect | DocGraphicInputCircle | DocGraphicInputLine);
+    /** Set options and defaults */
+    setOptions(input: DocGraphicInputBase | DocGraphicInputRect | DocGraphicInputCircle | DocGraphicInputLine): void;
+    toData(): Promise<ContainerData>;
+}

package/dist/src/DocPageContainerImage.d.ts

@@ -0,0 +1,21 @@
+import { Container, ContainerData, ContainerAlignment, ImageOptionsFit, ImageOptions } from './internal';
+export declare class Image extends Container {
+    DEFAULT_FIT: ImageOptionsFit;
+    DEFAULT_ALIGN: ContainerAlignment;
+    DEFAULT_BRIGHTNESS: number;
+    DEFAULT_CONTRAST: number;
+    DEFAULT_SATURATION: number;
+    DEFAULT_GRAYSCALE: number;
+    _url: string;
+    _options: ImageOptions;
+    constructor(url: string, options: ImageOptions);
+    urlToName(url: string): string;
+    /** Set options and defaults */
+    setOptions(options: ImageOptions): void;
+    toData(cache?: Record<string, any> | undefined): Promise<ContainerData>;
+    /** We want to load the raw data of the image in the ContainerContent for easy access later (in HTML and PDF exporter) */
+    loadImageData(cache?: Record<string, any> | undefined): Promise<any>;
+    /** Export image data as DataUrl base64 string */
+    _exportImageDataBase64(data: ArrayBuffer): string;
+    getImageFormat(): 'jpg' | 'png' | 'svg';
+}

package/dist/src/DocPageContainerTable.d.ts

@@ -0,0 +1,21 @@
+import { Container, ContainerData, DataRows, TableContainerOptions } from './internal';
+export declare class TableContainer extends Container {
+    DEFAULT_FONT_SIZE: number;
+    DEFAULT_FONT_COLOR: string;
+    DEFAULT_TABLE_PIVOT_POSITION: number[];
+    DEFAULT_TABLE_POSITION: number[];
+    DEFAULT_TABLE_WIDTH: string;
+    DEFAULT_TABLE_HEIGHT: string;
+    _data: DataRows;
+    _options: TableContainerOptions;
+    constructor(data: DataRows, options: TableContainerOptions);
+    /** with Text Container width/height is less important than position and size - reflect this in setting to null by default */
+    _setDefaults(): void;
+    /** Set options and defaults */
+    setOptions(options?: TableContainerOptions): void;
+    /** Set size of text in traditional 'points'. Real doc units (mm,cm,inch) are converted to points */
+    _setFontSize(size: number | string): void;
+    /** Convert to Color hex with chroma */
+    _setFontColor(color: string): void;
+    toData(): Promise<ContainerData>;
+}

package/dist/src/DocPageContainerText.d.ts

@@ -0,0 +1,23 @@
+import { Container, ContainerData, TextOptions } from './internal';
+export declare class Text extends Container {
+    DEFAULT_SIZE: string;
+    DEFAULT_COLOR: string;
+    DEFAULT_TEXT_PIVOT_POSITION: number[];
+    DEFAULT_TEXT_POSITION: number[];
+    FONT_SIZE_TO_HEIGHT_FACTOR: number;
+    _text: string;
+    _origOptions: TextOptions;
+    _options: TextOptions;
+    constructor(text: string, options: TextOptions);
+    /** with Text Container width/height is less important than position and size - reflect this in setting to null by default */
+    _setDefaults(): void;
+    /** Set options after added to page (overriden from parent class) */
+    _onPlaced(options?: TextOptions): void;
+    /** Set size of text in traditional 'points'. Real doc units (mm,cm,inch) are converted to points
+     *  NOTE: a measure relative to page height does not work here!
+    */
+    _setSize(size: number | string): void;
+    /** Convert to Color hex with chroma */
+    _setColor(color: string): void;
+    toData(): Promise<ContainerData>;
+}

package/dist/src/DocPageContainerTextArea.d.ts

@@ -0,0 +1,23 @@
+import { Container, TextAreaAlign, TextAreaOptions } from './internal';
+export declare class TextArea extends Container {
+    DEFAULT_SIZE: string;
+    DEFAULT_COLOR: string;
+    DEFAULT_ALIGN: TextAreaAlign;
+    DEFAULT_TEXTAREA_PIVOT_POSITION: number[];
+    DEFAULT_TEXTAREA_POSITION: number[];
+    DEFAULT_TEXTAREA_WIDTH: string;
+    DEFAULT_TEXTAREA_HEIGHT: string;
+    _text: string;
+    _options: TextAreaOptions;
+    constructor(text: string, options: TextAreaOptions);
+    _setDefaults(): void;
+    /** Set options and defaults */
+    setOptions(options?: TextAreaOptions): void;
+    /** Set size of text in traditional 'points'. Real doc units (mm,cm,inch) are converted to points */
+    _setSize(size: number | string): void;
+    /** Convert to Color hex with chroma */
+    _setColor(color: string): void;
+    /** Set alignment */
+    _setAlignment(align: TextAreaAlign): void;
+    toData(): Promise<any>;
+}

package/dist/src/DocPageContainerView.d.ts

@@ -0,0 +1,22 @@
+import { Container, ContainerData, AnyShapeOrCollection, ShapeCollection } from './internal';
+export declare class View extends Container {
+    _shapes: ShapeCollection | string;
+    _resolvedShapesSVG: string;
+    _style: any;
+    _styles: {
+        [key: string]: any;
+    };
+    _dimension: any;
+    _forceAll: boolean;
+    constructor();
+    toData(): Promise<ContainerData>;
+    /** For components we need to remove all references to Shapes */
+    resolveShapesToSVG(): string;
+    resolveShapeNameToSVG(shapesRef: string): string;
+    /** Bind ShapeCollection to View */
+    shapes(shapes: AnyShapeOrCollection | string, all?: boolean): void;
+    /** Used to remove DocDocument instances from execution scope
+     *  Used in components
+     */
+    resolveScopeReferences(): this;
+}

package/dist/src/DocUtils.d.ts

@@ -0,0 +1,12 @@
+/**
+ *  DocUtils.ts
+ *      Utility functions related to handling documents with Doc module
+ *
+ */
+export declare const POINTS_TO_DOC_UNITS: {
+    mm: number;
+    cm: number;
+    inch: number;
+};
+/** Convert value with units to font point size */
+export declare function convertSizeUnitsToFontPoints(size: number | string): number;