@lofcz/pptist 2.0.0

package/dist/types/types/toolbar.d.ts

@@ -0,0 +1,9 @@
+export declare const enum ToolbarStates {
+    EL_ANIMATION = "elAnimation",
+    EL_STYLE = "elStyle",
+    EL_POSITION = "elPosition",
+    SLIDE_DESIGN = "slideDesign",
+    SLIDE_ANIMATION = "slideAnimation",
+    MULTI_STYLE = "multiStyle",
+    MULTI_POSITION = "multiPosition"
+}

package/dist/types/utils/clipboard.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 复制文本到剪贴板
+ * @param text 文本内容
+ */
+export declare const copyText: (text: string) => Promise<unknown>;
+export declare const readClipboard: () => Promise<string>;
+export declare const pasteCustomClipboardString: (text: string) => any;
+export declare const pasteExcelClipboardString: (text: string) => string[][] | null;
+export declare const pasteHTMLTableClipboardString: (text: string) => string[][] | null;

package/dist/types/utils/common.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Pad the number of digits
+ * @param digit number
+ * @param len length
+ */
+export declare const fillDigit: (digit: number, len: number) => string;
+/**
+ * Check the device
+ */
+export declare const isPC: () => boolean;
+/**
+ * Check the URL string
+ */
+export declare const isValidURL: (url: string) => boolean;
+/**
+ * HTML转纯文本
+ */
+export declare const htmlToText: (html: string) => string;
+/**
+ * 浮点数比较
+ */
+export declare const isFloatEqual: (a: number, b: number, epsilon?: number) => boolean;

package/dist/types/utils/crypto.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Encrypt
+ * @param msg String to be encrypted
+ */
+export declare const encrypt: (msg: string) => string;
+/**
+ * Decrypt
+ * @param ciphertext String to be decrypted
+ */
+export declare const decrypt: (ciphertext: string) => string;

package/dist/types/utils/database.d.ts

@@ -0,0 +1,17 @@
+import Dexie, { type EntityTable } from 'dexie';
+import type { Slide } from '../types/slides';
+export interface writingBoardImg {
+    id: string;
+    dataURL: string;
+}
+export interface Snapshot {
+    id: number;
+    index: number;
+    slides: Slide[];
+}
+export declare const deleteDiscardedDB: () => Promise<void>;
+declare const db: Dexie & {
+    snapshots: EntityTable<Snapshot, "id">;
+    writingBoardImgs: EntityTable<writingBoardImg, "id">;
+};
+export { db };

package/dist/types/utils/element.d.ts

@@ -0,0 +1,304 @@
+import type { PPTElement, PPTLineElement, Slide } from '../types/slides';
+interface RotatedElementData {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    rotate: number;
+}
+interface Point {
+    x: number;
+    y: number;
+}
+interface IdMap {
+    [id: string]: string;
+}
+/**
+ * Bounding box of an element's rect after rotation on the canvas.
+ * @param element Position, size, and rotation of the element
+ */
+export declare const getRectRotatedRange: (element: RotatedElementData) => {
+    xRange: number[];
+    yRange: number[];
+};
+/**
+ * Offset between an element's axis-aligned bounds before and after rotation.
+ * @param element Position, size, and rotation of the element
+ */
+export declare const getRectRotatedOffset: (element: RotatedElementData) => {
+    offsetX: number;
+    offsetY: number;
+};
+/**
+ * Axis-aligned bounds of a single element on the canvas.
+ * @param element Element data
+ */
+export declare const getElementRange: (element: PPTElement) => {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+};
+/**
+ * Combined axis-aligned bounds of multiple elements on the canvas.
+ * @param elementList Elements to measure
+ */
+export declare const getElementListRange: (elementList: PPTElement[]) => {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+};
+/**
+ * Whether the selection is the full membership of a single group.
+ * @param elements Selected elements
+ */
+export declare const isSingleGroupSelection: (elements: PPTElement[]) => boolean;
+/**
+ * Whether the group can be rotated as a unit.
+ * @param elements Group members
+ */
+export declare const canRotateGroupElements: (elements: PPTElement[]) => boolean;
+/**
+ * Center of the combined bounds of a set of elements.
+ * @param elements Elements in the group
+ * @param rotate Reference rotation: bounds are aligned to this angle before computing the center
+ */
+export declare const getGroupElementCenter: (elements: PPTElement[], rotate?: number) => Point;
+/**
+ * Normalize an angle to the [-180, 180] range.
+ * @param angle Angle in degrees
+ */
+export declare const normalizeAngle: (angle: number) => number;
+/**
+ * Rotate a point around a center by the given angle.
+ * @param point Point to rotate
+ * @param center Rotation center
+ * @param angle Rotation in degrees
+ */
+export declare const rotatePoint: (point: Point, center: Point, angle: number) => Point;
+/**
+ * Rotate a rect-like element by rotating its center and adding to `rotate`.
+ * @param element Element to rotate
+ * @param center Group rotation center
+ * @param angle Rotation in degrees
+ */
+export declare const rotateRectLikeElement: (element: Exclude<PPTElement, PPTLineElement>, center: Point, angle: number) => {
+    left: number;
+    top: number;
+    rotate: number;
+    type: "text";
+    content: string;
+    defaultFontName: string;
+    defaultColor: string;
+    outline?: import("../types/slides").PPTElementOutline;
+    fill?: string;
+    lineHeight?: number;
+    wordSpace?: number;
+    opacity?: number;
+    shadow?: import("../types/slides").PPTElementShadow;
+    paragraphSpace?: number;
+    vertical?: boolean;
+    textType?: import("../types/slides").TextType;
+    inset?: import("../types/slides").TextInset;
+    id: string;
+    lock?: boolean;
+    groupId?: string;
+    width: number;
+    height: number;
+    link?: import("../types/slides").PPTElementLink;
+    name?: string;
+} | {
+    left: number;
+    top: number;
+    rotate: number;
+    type: "image";
+    fixedRatio: boolean;
+    src: string;
+    outline?: import("../types/slides").PPTElementOutline;
+    filters?: import("../types/slides").ImageElementFilters;
+    clip?: import("../types/slides").ImageElementClip;
+    flipH?: boolean;
+    flipV?: boolean;
+    shadow?: import("../types/slides").PPTElementShadow;
+    radius?: number;
+    colorMask?: string;
+    imageType?: import("../types/slides").ImageType;
+    id: string;
+    lock?: boolean;
+    groupId?: string;
+    width: number;
+    height: number;
+    link?: import("../types/slides").PPTElementLink;
+    name?: string;
+} | {
+    left: number;
+    top: number;
+    rotate: number;
+    type: "shape";
+    viewBox: [number, number];
+    path: string;
+    fixedRatio: boolean;
+    fill: string;
+    gradient?: import("../types/slides").Gradient;
+    pattern?: string;
+    outline?: import("../types/slides").PPTElementOutline;
+    opacity?: number;
+    flipH?: boolean;
+    flipV?: boolean;
+    shadow?: import("../types/slides").PPTElementShadow;
+    special?: boolean;
+    text?: import("../types/slides").ShapeText;
+    pathFormula?: import("../types/slides").ShapePathFormulasKeys;
+    keypoints?: number[];
+    id: string;
+    lock?: boolean;
+    groupId?: string;
+    width: number;
+    height: number;
+    link?: import("../types/slides").PPTElementLink;
+    name?: string;
+} | {
+    left: number;
+    top: number;
+    rotate: number;
+    type: "chart";
+    fill?: string;
+    chartType: import("../types/slides").ChartType;
+    data: import("../types/slides").ChartData;
+    options?: import("../types/slides").ChartOptions;
+    outline?: import("../types/slides").PPTElementOutline;
+    themeColors: string[];
+    textColor?: string;
+    lineColor?: string;
+    id: string;
+    lock?: boolean;
+    groupId?: string;
+    width: number;
+    height: number;
+    link?: import("../types/slides").PPTElementLink;
+    name?: string;
+} | {
+    left: number;
+    top: number;
+    rotate: number;
+    type: "table";
+    outline: import("../types/slides").PPTElementOutline;
+    theme?: import("../types/slides").TableTheme;
+    colWidths: number[];
+    cellMinHeight: number;
+    data: import("../types/slides").TableCell[][];
+    id: string;
+    lock?: boolean;
+    groupId?: string;
+    width: number;
+    height: number;
+    link?: import("../types/slides").PPTElementLink;
+    name?: string;
+} | {
+    left: number;
+    top: number;
+    rotate: number;
+    type: "latex";
+    latex: string;
+    path: string;
+    color: string;
+    strokeWidth: number;
+    viewBox: [number, number];
+    fixedRatio: boolean;
+    id: string;
+    lock?: boolean;
+    groupId?: string;
+    width: number;
+    height: number;
+    link?: import("../types/slides").PPTElementLink;
+    name?: string;
+} | {
+    left: number;
+    top: number;
+    rotate: number;
+    type: "video";
+    src: string;
+    autoplay: boolean;
+    poster?: string;
+    ext?: string;
+    id: string;
+    lock?: boolean;
+    groupId?: string;
+    width: number;
+    height: number;
+    link?: import("../types/slides").PPTElementLink;
+    name?: string;
+} | {
+    left: number;
+    top: number;
+    rotate: number;
+    type: "audio";
+    fixedRatio: boolean;
+    color: string;
+    loop: boolean;
+    autoplay: boolean;
+    src: string;
+    ext?: string;
+    id: string;
+    lock?: boolean;
+    groupId?: string;
+    width: number;
+    height: number;
+    link?: import("../types/slides").PPTElementLink;
+    name?: string;
+};
+/**
+ * Rotate a line element by rotating all control points and rebuilding line data.
+ * @param element Line element
+ * @param center Group rotation center
+ * @param angle Rotation in degrees
+ */
+export declare const rotateLineElement: (element: PPTLineElement, center: Point, angle: number) => PPTLineElement;
+export declare const getLineElementLength: (element: PPTLineElement) => number;
+export declare const getBroken2LineDirection: (element: PPTLineElement) => import("../types/slides").Broken2LineDirection;
+export interface AlignLine {
+    value: number;
+    range: [number, number];
+}
+/**
+ * Deduplicate alignment snap lines at the same position; merge their ranges to min/max.
+ * @param lines Alignment snap lines
+ */
+export declare const uniqAlignLines: (lines: AlignLine[]) => AlignLine[];
+/**
+ * Map each slide id to a new id (used when duplicating slides to preserve references).
+ * @param slides Slide list
+ */
+export declare const createSlideIdMap: (slides: Slide[]) => IdMap;
+/**
+   * Map each element (and group) id to a new id when copying elements.
+   * e.g. two grouped elements keep the same new groupId after copy.
+   * @param elements Element list
+   */
+export declare const createElementIdMap: (elements: PPTElement[]) => {
+    groupIdMap: IdMap;
+    elIdMap: IdMap;
+};
+/**
+ * Derive table sub-theme colors (with alpha) from a theme color.
+ * @param themeColor Base theme color
+ */
+export declare const getTableSubThemeColor: (themeColor: string) => string[];
+/**
+ * SVG path `d` attribute for a line element (logical geometry).
+ * @param element Line element
+ */
+export declare const getLineElementPath: (element: PPTLineElement) => string;
+/**
+ * SVG path for rendering a line: markers stay at original start/end; stroke is inset at caps.
+ * @param element Line element
+ */
+export declare const getLineElementRenderPath: (element: PPTLineElement) => string;
+/**
+ * Whether an element is fully visible within a scroll parent's viewport (vertical).
+ * @param element DOM element
+ * @param parent Scroll container
+ */
+export declare const isElementInViewport: (element: HTMLElement, parent: HTMLElement) => boolean;
+export {};

package/dist/types/utils/emitter.d.ts

@@ -0,0 +1,23 @@
+import { type Emitter } from 'mitt';
+export declare const enum EmitterEvents {
+    RICH_TEXT_COMMAND = "RICH_TEXT_COMMAND",
+    SYNC_RICH_TEXT_ATTRS_TO_STORE = "SYNC_RICH_TEXT_ATTRS_TO_STORE",
+    OPEN_CHART_DATA_EDITOR = "OPEN_CHART_DATA_EDITOR",
+    OPEN_LATEX_EDITOR = "OPEN_LATEX_EDITOR"
+}
+export interface RichTextAction {
+    command: string;
+    value?: string;
+}
+export interface RichTextCommand {
+    target?: string;
+    action: RichTextAction | RichTextAction[];
+}
+type Events = {
+    [EmitterEvents.RICH_TEXT_COMMAND]: RichTextCommand;
+    [EmitterEvents.SYNC_RICH_TEXT_ATTRS_TO_STORE]: void;
+    [EmitterEvents.OPEN_CHART_DATA_EDITOR]: void;
+    [EmitterEvents.OPEN_LATEX_EDITOR]: void;
+};
+declare const emitter: Emitter<Events>;
+export default emitter;

package/dist/types/utils/font.d.ts

@@ -0,0 +1 @@
+export declare const isSystemFont: (font: string) => boolean;

package/dist/types/utils/fullscreen.d.ts

@@ -0,0 +1,3 @@
+export declare const enterFullscreen: () => void;
+export declare const exitFullscreen: () => void;
+export declare const isFullscreen: () => boolean;

package/dist/types/utils/htmlParser/format.d.ts

@@ -0,0 +1,3 @@
+import type { HTMLNode, AST } from './types';
+export declare const splitHead: (str: string, sep: string) => string[];
+export declare const format: (nodes: HTMLNode[]) => AST[];

package/dist/types/utils/htmlParser/index.d.ts

@@ -0,0 +1,4 @@
+import { toHTML } from './stringify';
+export type { AST } from './types';
+export declare const toAST: (str: string) => import("./types").AST[];
+export { toHTML };

package/dist/types/utils/htmlParser/lexer.d.ts

@@ -0,0 +1,2 @@
+import type { Token } from './types';
+export declare const lexer: (str: string) => Token[];

package/dist/types/utils/htmlParser/parser.d.ts

@@ -0,0 +1,15 @@
+import type { Token, HTMLNode } from './types';
+interface StackItem {
+    tagName: string | null;
+    children: HTMLNode[];
+}
+interface State {
+    stack: StackItem[];
+    cursor: number;
+    tokens: Token[];
+}
+export declare const parser: (tokens: Token[]) => HTMLNode[];
+export declare const hasTerminalParent: (tagName: string, stack: StackItem[]) => boolean;
+export declare const rewindStack: (stack: StackItem[], newLength: number) => void;
+export declare const parse: (state: State) => void;
+export {};

package/dist/types/utils/htmlParser/stringify.d.ts

@@ -0,0 +1,3 @@
+import type { AST, ElementAttribute } from './types';
+export declare const formatAttributes: (attributes: ElementAttribute[]) => string;
+export declare const toHTML: (tree: AST[]) => string;

package/dist/types/utils/htmlParser/tags.d.ts

@@ -0,0 +1,4 @@
+export declare const childlessTags: string[];
+export declare const closingTags: string[];
+export declare const closingTagAncestorBreakers: Record<string, string[]>;
+export declare const voidTags: string[];

package/dist/types/utils/htmlParser/types.d.ts

@@ -0,0 +1,55 @@
+export interface ElementAttribute {
+    key: string;
+    value: string | null;
+}
+export interface CommentElement {
+    type: 'comment';
+    content: string;
+}
+export interface TextElement {
+    type: 'text';
+    content: string;
+}
+export interface NormalElement {
+    type: 'element';
+    tagName: string;
+    children: HTMLNode[];
+    attributes: string[];
+}
+export type HTMLNode = CommentElement | TextElement | NormalElement;
+export interface ElementAST {
+    type: 'element';
+    tagName: string;
+    children: AST[];
+    attributes: ElementAttribute[];
+}
+export interface CommentOrTextAST {
+    type: 'comment' | 'text';
+    content: string;
+}
+export type AST = CommentOrTextAST | ElementAST;
+export interface TagStartToken {
+    type: 'tag-start';
+    close: boolean;
+}
+export interface TagEndToken {
+    type: 'tag-end';
+    close: boolean;
+}
+export interface TagToken {
+    type: 'tag';
+    content: string;
+}
+export interface TextToken {
+    type: 'text';
+    content: string;
+}
+export interface CommentToken {
+    type: 'comment';
+    content: string;
+}
+export interface AttributeToken {
+    type: 'attribute';
+    content: string;
+}
+export type Token = TagStartToken | TagEndToken | TagToken | TextToken | CommentToken | AttributeToken;

package/dist/types/utils/image.d.ts

@@ -0,0 +1,25 @@
+interface ImageSize {
+    width: number;
+    height: number;
+}
+/**
+ * Get the intrinsic width and height of an image.
+ * @param src Image URL
+ */
+export declare const getImageSize: (src: string) => Promise<ImageSize>;
+/**
+ * Read an image file as a data URL.
+ * @param file Image file
+ */
+export declare const getImageDataURL: (file: File) => Promise<string>;
+/**
+ * Check whether a string is SVG markup.
+ * @param text Text to validate
+ */
+export declare const isSVGString: (text: string) => boolean;
+/**
+ * Convert SVG markup to a File.
+ * @param svg SVG markup
+ */
+export declare const svg2File: (svg: string) => File;
+export {};

package/dist/types/utils/message.d.ts

@@ -0,0 +1,28 @@
+import { type AppContext } from 'vue';
+export interface MessageOptions {
+    type?: 'info' | 'success' | 'warning' | 'error' | 'loading';
+    title?: string;
+    message?: string;
+    duration?: number;
+    closable?: boolean;
+    ctx?: AppContext;
+    onClose?: () => void;
+}
+export type MessageTypeOptions = Omit<MessageOptions, 'type' | 'message'>;
+export interface MessageIntance {
+    id: string;
+    close: () => void;
+}
+export type MessageFn = (message: string, options?: MessageTypeOptions) => MessageIntance;
+export interface Message {
+    (options: MessageOptions): MessageIntance;
+    info: MessageFn;
+    success: MessageFn;
+    error: MessageFn;
+    warning: MessageFn;
+    loading: MessageFn;
+    closeAll: () => void;
+    _context?: AppContext | null;
+}
+declare const message: Message;
+export default message;

package/dist/types/utils/portal.d.ts

@@ -0,0 +1,5 @@
+export declare function setPptistPortalTarget(target: HTMLElement | null): void;
+export declare function clearPptistPortalTarget(target: HTMLElement): void;
+export declare function getPptistPortalTarget(): HTMLElement;
+export declare function queryPptist<T extends Element = Element>(selector: string): T | null;
+export declare function queryPptistAll<T extends Element = Element>(selector: string): NodeListOf<T>;

package/dist/types/utils/print.d.ts

@@ -0,0 +1,7 @@
+interface PageSize {
+    width: number;
+    height: number;
+    margin: number;
+}
+export declare const print: (printNode: HTMLElement, size: PageSize) => void;
+export {};

package/dist/types/utils/prosemirror/commands/replaceText.d.ts

@@ -0,0 +1,2 @@
+import { EditorView } from 'prosemirror-view';
+export declare const replaceText: (view: EditorView, newText: string) => void;

package/dist/types/utils/prosemirror/commands/setListStyle.d.ts

@@ -0,0 +1,4 @@
+import type { EditorView } from 'prosemirror-view';
+type Style = Record<string, string>;
+export declare const setListStyle: (view: EditorView, style: Style | Style[]) => import("prosemirror-state").Transaction | undefined;
+export {};

package/dist/types/utils/prosemirror/commands/setTextAlign.d.ts

@@ -0,0 +1,5 @@
+import type { Schema } from 'prosemirror-model';
+import type { Transaction } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+export declare const setTextAlign: (tr: Transaction, schema: Schema, alignment: string) => Transaction;
+export declare const alignmentCommand: (view: EditorView, alignment: string) => void;

package/dist/types/utils/prosemirror/commands/setTextIndent.d.ts

@@ -0,0 +1,3 @@
+import type { EditorView } from 'prosemirror-view';
+export declare const indentCommand: (view: EditorView, delta: number) => boolean;
+export declare const textIndentCommand: (view: EditorView, delta: number) => boolean;

package/dist/types/utils/prosemirror/commands/toggleList.d.ts

@@ -0,0 +1,8 @@
+import type { NodeType } from 'prosemirror-model';
+import type { Transaction, EditorState } from 'prosemirror-state';
+interface TextStyleAttr {
+    color?: string;
+    fontsize?: string;
+}
+export declare const toggleList: (listType: NodeType, itemType: NodeType, listStyleType: string, textStyleAttr?: TextStyleAttr) => (state: EditorState, dispatch: (tr: Transaction) => void) => boolean;
+export {};

package/dist/types/utils/prosemirror/index.d.ts

@@ -0,0 +1,4 @@
+import { type DirectEditorProps, EditorView } from 'prosemirror-view';
+import { type PluginOptions } from './plugins/index';
+export declare const createDocument: (content: string) => import("prosemirror-model").Node;
+export declare const initProsemirrorEditor: (dom: Element, content: string, props: Omit<DirectEditorProps, "state">, pluginOptions?: PluginOptions) => EditorView;

package/dist/types/utils/prosemirror/plugins/index.d.ts

@@ -0,0 +1,10 @@
+import type { Schema } from 'prosemirror-model';
+export interface PluginOptions {
+    placeholder?: string;
+}
+export declare const buildPlugins: (schema: Schema, options?: PluginOptions) => (import("prosemirror-state").Plugin<{
+    transform: import("prosemirror-state").Transaction;
+    from: number;
+    to: number;
+    text: string;
+} | null> | import("prosemirror-state").Plugin<any>)[];

package/dist/types/utils/prosemirror/plugins/inputrules.d.ts

@@ -0,0 +1,7 @@
+import type { Schema } from 'prosemirror-model';
+export declare const buildInputRules: (schema: Schema) => import("prosemirror-state").Plugin<{
+    transform: import("prosemirror-state").Transaction;
+    from: number;
+    to: number;
+    text: string;
+} | null>;

package/dist/types/utils/prosemirror/plugins/keymap.d.ts

@@ -0,0 +1,3 @@
+import type { Schema } from 'prosemirror-model';
+import type { Command } from 'prosemirror-state';
+export declare const buildKeymap: (schema: Schema) => Record<string, Command>;

package/dist/types/utils/prosemirror/plugins/placeholder.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from 'prosemirror-state';
+export declare const placeholderPlugin: (placeholder: string) => Plugin<any>;

package/dist/types/utils/prosemirror/schema/index.d.ts

@@ -0,0 +1,25 @@
+export declare const schemaNodes: {
+    doc: import("prosemirror-model").NodeSpec;
+    paragraph: import("prosemirror-model").NodeSpec;
+    blockquote: import("prosemirror-model").NodeSpec;
+    text: import("prosemirror-model").NodeSpec;
+    ordered_list: import("prosemirror-model").NodeSpec;
+    bullet_list: import("prosemirror-model").NodeSpec;
+    list_item: import("prosemirror-model").NodeSpec;
+};
+export declare const schemaMarks: {
+    em: import("prosemirror-model").MarkSpec;
+    strong: import("prosemirror-model").MarkSpec;
+    fontsize: import("prosemirror-model").MarkSpec;
+    fontname: import("prosemirror-model").MarkSpec;
+    code: import("prosemirror-model").MarkSpec;
+    textgradient: import("prosemirror-model").MarkSpec;
+    forecolor: import("prosemirror-model").MarkSpec;
+    backcolor: import("prosemirror-model").MarkSpec;
+    subscript: import("prosemirror-model").MarkSpec;
+    superscript: import("prosemirror-model").MarkSpec;
+    strikethrough: import("prosemirror-model").MarkSpec;
+    underline: import("prosemirror-model").MarkSpec;
+    link: import("prosemirror-model").MarkSpec;
+    mark: import("prosemirror-model").MarkSpec;
+};