@yannelli/live-markdown-vue 1.0.2 → 1.0.3

package/dist/App.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/components/MarkdownEditor.vue.d.ts

@@ -0,0 +1,304 @@
+import { ToolbarButtonName, MarkdownEditorProps } from '../types';
+type __VLS_Props = MarkdownEditorProps;
+type __VLS_PublicProps = {
+    modelValue?: string;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {
+    getEditor: () => {
+        value: {
+            (): string;
+            (val: string): void;
+        };
+        codemirror: {
+            hasFocus: {
+                (): boolean;
+                (): boolean;
+            };
+            findPosH: (start: CodeMirror.Position, amount: number, unit: string, visually: boolean) => {
+                line: number;
+                ch: number;
+                hitSide?: boolean | undefined;
+            };
+            findPosV: (start: CodeMirror.Position, amount: number, unit: string) => {
+                line: number;
+                ch: number;
+                hitSide?: boolean | undefined;
+            };
+            findWordAt: (pos: CodeMirror.Position) => CodeMirror.Range;
+            setOption: {
+                <K extends keyof CodeMirror.EditorConfiguration>(option: K, value: CodeMirror.EditorConfiguration[K]): void;
+                (option: string, value: unknown): void;
+            };
+            getOption: <K extends keyof CodeMirror.EditorConfiguration>(option: K) => CodeMirror.EditorConfiguration[K];
+            addKeyMap: (map: string | CodeMirror.KeyMap, bottom?: boolean) => void;
+            removeKeyMap: (map: string | CodeMirror.KeyMap) => void;
+            addOverlay: (mode: any, options?: {
+                opaque?: boolean | undefined;
+                priority?: number | undefined;
+            }) => void;
+            removeOverlay: (mode: any) => void;
+            getDoc: () => CodeMirror.Doc;
+            swapDoc: (doc: CodeMirror.Doc) => CodeMirror.Doc;
+            getValue: {
+                (seperator?: string): string;
+                (): string;
+            };
+            setValue: {
+                (content: string): void;
+                (value: string): void;
+            };
+            getCursor: (start?: string) => CodeMirror.Position;
+            setCursor: (pos: CodeMirror.Position | number, ch?: number, options?: {
+                bias?: number | undefined;
+                origin?: string | undefined;
+                scroll?: boolean | undefined;
+            }) => void;
+            setGutterMarker: (line: any, gutterID: string, value: HTMLElement | null) => CodeMirror.LineHandle;
+            clearGutter: (gutterID: string) => void;
+            addLineClass: (line: any, where: string, _class_: string) => CodeMirror.LineHandle;
+            removeLineClass: (line: any, where: string, class_?: string) => CodeMirror.LineHandle;
+            lineAtHeight: (height: number, mode?: CodeMirror.CoordsMode) => number;
+            heightAtLine: (line: any, mode?: CodeMirror.CoordsMode, includeWidgets?: boolean) => number;
+            lineInfo: (line: any) => {
+                line: any;
+                handle: any;
+                text: string;
+                gutterMarkers: any;
+                textClass: string;
+                bgClass: string;
+                wrapClass: string;
+                widgets: any;
+            };
+            addWidget: (pos: CodeMirror.Position, node: HTMLElement, scrollIntoView: boolean) => void;
+            addLineWidget: (line: any, node: HTMLElement, options?: CodeMirror.LineWidgetOptions) => CodeMirror.LineWidget;
+            setSize: (width: any, height: any) => void;
+            scrollTo: (x?: number | null, y?: number | null) => void;
+            getScrollInfo: () => CodeMirror.ScrollInfo;
+            scrollIntoView: (pos: CodeMirror.Position | null | {
+                line: number;
+                ch: number;
+            } | {
+                left: number;
+                top: number;
+                right: number;
+                bottom: number;
+            } | {
+                from: CodeMirror.Position;
+                to: CodeMirror.Position;
+            }, margin?: number) => void;
+            cursorCoords: (where?: boolean | CodeMirror.Position | null, mode?: CodeMirror.CoordsMode) => {
+                left: number;
+                top: number;
+                bottom: number;
+            };
+            charCoords: (pos: CodeMirror.Position, mode?: CodeMirror.CoordsMode) => {
+                left: number;
+                right: number;
+                top: number;
+                bottom: number;
+            };
+            coordsChar: (object: {
+                left: number;
+                top: number;
+            }, mode?: CodeMirror.CoordsMode) => CodeMirror.Position;
+            defaultTextHeight: () => number;
+            defaultCharWidth: () => number;
+            getViewport: () => {
+                from: number;
+                to: number;
+            };
+            refresh: () => void;
+            getModeAt: (pos: CodeMirror.Position) => CodeMirror.Mode<unknown>;
+            getTokenAt: (pos: CodeMirror.Position, precise?: boolean) => CodeMirror.Token;
+            getTokenTypeAt: (pos: CodeMirror.Position) => string;
+            getLineTokens: (line: number, precise?: boolean) => CodeMirror.Token[];
+            getStateAfter: (line?: number) => any;
+            operation: <T>(fn: () => T) => T;
+            startOperation: () => void;
+            endOperation: () => void;
+            indentLine: (line: number, dir?: string | null, aggresive?: boolean) => void;
+            indentSelection: (how: string) => void;
+            isReadOnly: () => boolean;
+            toggleOverwrite: (value?: boolean) => void;
+            execCommand: (name: string) => void;
+            focus: {
+                (): void;
+                (): void;
+            };
+            phrase: (text: string) => unknown;
+            getInputField: () => HTMLTextAreaElement;
+            getWrapperElement: {
+                (): HTMLElement;
+                (): HTMLElement;
+            };
+            getScrollerElement: () => HTMLElement;
+            getGutterElement: () => HTMLElement;
+            on: {
+                <T extends keyof CodeMirror.EditorEventMap>(eventName: T, handler: CodeMirror.EditorEventMap[T]): void;
+                <K extends CodeMirror.DOMEvent & keyof GlobalEventHandlersEventMap>(eventName: K, handler: (instance: CodeMirror.Editor, event: GlobalEventHandlersEventMap[K]) => void): void;
+                (event: string, handler: (...args: unknown[]) => void): void;
+            };
+            off: {
+                <T extends keyof CodeMirror.EditorEventMap>(eventName: T, handler: CodeMirror.EditorEventMap[T]): void;
+                <K extends CodeMirror.DOMEvent & keyof GlobalEventHandlersEventMap>(eventName: K, handler: (instance: CodeMirror.Editor, event: GlobalEventHandlersEventMap[K]) => void): void;
+                (event: string, handler: (...args: unknown[]) => void): void;
+            };
+            state: any;
+            setSelection: (from: CodeMirror.Position, to: CodeMirror.Position) => void;
+            modeOption: string | {
+                highlightNonStandardPropertyKeywords?: boolean | undefined | undefined;
+                version?: 2 | 3 | undefined | undefined;
+                singleLineStringErrors?: boolean | undefined | undefined;
+                hangingIndent?: number | undefined | undefined;
+                singleOperators?: unknown | undefined;
+                singleDelimiters?: unknown | undefined;
+                doubleOperators?: unknown | undefined;
+                doubleDelimiters?: unknown | undefined;
+                tripleDelimiters?: unknown | undefined;
+                identifiers?: unknown | undefined;
+                extra_keywords?: string[] | undefined | undefined;
+                extra_builtins?: string[] | undefined | undefined;
+                useCPP?: boolean | undefined | undefined;
+                base?: string | undefined | undefined;
+                tags?: {
+                    [key: string]: unknown;
+                } | undefined | undefined;
+                json?: boolean | undefined | undefined;
+                jsonld?: boolean | undefined | undefined;
+                typescript?: boolean | undefined | undefined;
+                trackScope?: boolean | undefined | undefined;
+                statementIndent?: boolean | undefined | undefined;
+                wordCharacters?: unknown | undefined;
+                highlightFormatting?: boolean | undefined | undefined;
+                maxBlockquoteDepth?: boolean | undefined | undefined;
+                xml?: boolean | undefined | undefined;
+                fencedCodeBlockHighlighting?: boolean | undefined | undefined;
+                fencedCodeBlockDefaultMode?: string | undefined | undefined;
+                tokenTypeOverrides?: unknown | undefined;
+                allowAtxHeaderWithoutSpace?: boolean | undefined | undefined;
+                gitHubSpice?: boolean | undefined | undefined;
+                taskLists?: boolean | undefined | undefined;
+                strikethrough?: boolean | undefined | undefined;
+                emoji?: boolean | undefined | undefined;
+                leftDelimiter?: string | undefined | undefined;
+                rightDelimiter?: string | undefined | undefined;
+                baseMode?: string | undefined | undefined;
+                inMathMode?: boolean | undefined | undefined;
+                noIndentKeywords?: unknown | undefined;
+                atoms?: unknown | undefined;
+                hooks?: unknown | undefined;
+                multiLineStrings?: boolean | undefined | undefined;
+                htmlMode?: boolean | undefined | undefined;
+                matchClosing?: boolean | undefined | undefined;
+                alignCDATA?: boolean | undefined | undefined;
+                name: string;
+            };
+            getRange: (from: CodeMirror.Position, to: CodeMirror.Position, seperator?: string) => string;
+            replaceRange: (replacement: string | string[], from: CodeMirror.Position, to?: CodeMirror.Position, origin?: string) => void;
+            getLine: (n: number) => string;
+            setLine: (n: number, text: string) => void;
+            removeLine: (n: number) => void;
+            lineCount: () => number;
+            firstLine: () => number;
+            lastLine: () => number;
+            getLineHandle: (num: number) => CodeMirror.LineHandle;
+            getLineNumber: (handle: CodeMirror.LineHandle) => number | null;
+            eachLine: {
+                (f: (line: CodeMirror.LineHandle) => void): void;
+                (start: number, end: number, f: (line: CodeMirror.LineHandle) => void): void;
+            };
+            markClean: () => void;
+            changeGeneration: (closeEvent?: boolean) => number;
+            isClean: (generation?: number) => boolean;
+            getSelection: () => string;
+            getSelections: (lineSep?: string) => string[];
+            replaceSelection: (replacement: string, collapse?: string | null, origin?: string | null) => void;
+            replaceSelections: (replacements: string[], collapse?: string | null, origin?: string | null) => void;
+            listSelections: () => CodeMirror.Range[];
+            somethingSelected: () => boolean;
+            setSelections: (ranges: Array<{
+                anchor: CodeMirror.Position;
+                head: CodeMirror.Position;
+            }>, primary?: number, options?: CodeMirror.SelectionOptions) => void;
+            addSelection: (anchor: CodeMirror.Position, head?: CodeMirror.Position) => void;
+            extendSelection: (from: CodeMirror.Position, to?: CodeMirror.Position, options?: CodeMirror.SelectionOptions) => void;
+            extendSelections: (heads: CodeMirror.Position[], options?: CodeMirror.SelectionOptions) => void;
+            extendSelectionsBy: (f: (range: CodeMirror.Range) => CodeMirror.Position) => void;
+            setExtending: (value: boolean) => void;
+            getExtending: () => boolean;
+            linkedDoc: (options: {
+                sharedHist?: boolean | undefined;
+                from?: number | undefined;
+                to?: number | undefined;
+                mode?: string | CodeMirror.ModeSpec<CodeMirror.ModeSpecOptions> | undefined;
+            }) => CodeMirror.Doc;
+            unlinkDoc: (doc: CodeMirror.Doc) => void;
+            iterLinkedDocs: (fn: (doc: CodeMirror.Doc, sharedHist: boolean) => void) => void;
+            undo: () => void;
+            redo: () => void;
+            undoSelection: () => void;
+            redoSelection: () => void;
+            historySize: () => {
+                undo: number;
+                redo: number;
+            };
+            clearHistory: () => void;
+            getHistory: () => any;
+            setHistory: (history: any) => void;
+            markText: (from: CodeMirror.Position, to: CodeMirror.Position, options?: CodeMirror.TextMarkerOptions) => CodeMirror.TextMarker<CodeMirror.MarkerRange>;
+            setBookmark: (pos: CodeMirror.Position, options?: {
+                widget?: HTMLElement | undefined;
+                insertLeft?: boolean | undefined;
+                shared?: boolean | undefined;
+                handleMouseEvents?: boolean | undefined;
+            }) => CodeMirror.TextMarker<CodeMirror.Position>;
+            findMarks: (from: CodeMirror.Position, to: CodeMirror.Position) => CodeMirror.TextMarker[];
+            findMarksAt: (pos: CodeMirror.Position) => CodeMirror.TextMarker[];
+            getAllMarks: () => CodeMirror.TextMarker[];
+            removeLineWidget: (widget: CodeMirror.LineWidget) => void;
+            getMode: () => CodeMirror.Mode<unknown>;
+            lineSeparator: () => string;
+            posFromIndex: (index: number) => CodeMirror.Position;
+            indexFromPos: (object: CodeMirror.Position) => number;
+        };
+        cleanup: () => void;
+        toTextArea: () => void;
+        isPreviewActive: () => boolean;
+        isSideBySideActive: () => boolean;
+        isFullscreenActive: () => boolean;
+        clearAutosavedValue: () => void;
+        updateStatusBar: (itemName: string, content: string) => void;
+    } | null;
+    focus: () => void | undefined;
+    blur: () => void;
+    getValue: () => string;
+    setValue: (value: string) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (...args: unknown[]) => any;
+    change: (value: string) => any;
+    blur: () => any;
+    focus: () => any;
+    upload: (file: File, onSuccess: (url: string) => void, onError: (message: string) => void) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: unknown[]) => any) | undefined;
+    onChange?: ((value: string) => any) | undefined;
+    onBlur?: (() => any) | undefined;
+    onFocus?: (() => any) | undefined;
+    onUpload?: ((file: File, onSuccess: (url: string) => void, onError: (message: string) => void) => any) | undefined;
+}>, {
+    disabled: boolean;
+    placeholder: string;
+    minHeight: string;
+    maxHeight: string;
+    autofocus: boolean;
+    spellcheck: boolean;
+    toolbarButtons: ToolbarButtonName[][];
+    canAttachFiles: boolean;
+    debounceMs: number;
+    translations: import('..').MarkdownEditorTranslations;
+    direction: "ltr" | "rtl";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    containerRef: HTMLDivElement;
+    editorRef: HTMLTextAreaElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { default as MarkdownEditor } from './components/MarkdownEditor.vue';
+import { App } from 'vue';
+export { MarkdownEditor };
+export * from './types';
+declare const _default: {
+    install(app: App): void;
+};
+export default _default;