@bluepic/embed 0.1.0

package/lib/components/RichText.vue.d.ts

@@ -0,0 +1,502 @@
+import { StyleValue } from 'vue';
+import { RichTextFeature } from '@bluepic/types';
+declare const _sfc_main: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: ArrayConstructor;
+        required: true;
+    };
+    selection: {
+        type: ObjectConstructor;
+        required: false;
+    };
+    userAgentRichText: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    renderFeatureInlineStyle: {
+        type: FunctionConstructor;
+        required: true;
+    };
+    maxLength: {
+        type: NumberConstructor;
+        required: true;
+    };
+    maxLengthPerLine: {
+        type: NumberConstructor;
+        required: true;
+    };
+    maxLines: {
+        type: NumberConstructor;
+        required: true;
+    };
+    multiline: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+}>, {
+    props: any;
+    emit: (event: "update:focus" | "update:selection" | "update:value" | "update:visible-value" | "update:warning-message", ...args: any[]) => void;
+    preventLinebreaks: import("vue").ComputedRef<boolean>;
+    richTextDisplayInstance: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        paragraphs: {
+            type: ArrayConstructor;
+            required: true;
+        };
+        noLazy: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        ghost: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        debug: {
+            type: BooleanConstructor;
+            required: false;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        onUpdate?: ((...args: any[]) => any) | undefined;
+    }>, {
+        props: any;
+        emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
+        richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+        lazyParagraphs: import("vue").Ref<any, any>;
+        handleInputEvent: (event: Event) => void;
+        handleFocus: (event: FocusEvent) => void;
+        handleBlur: (event: FocusEvent) => void;
+        richTextGlobalScopedStyleId: string;
+        richTextGlobalScopedStyleDataAttr: string;
+        writeCSS: (cssRules: StyleValue) => string;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
+        debug: boolean;
+        noLazy: boolean;
+        ghost: boolean;
+    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        paragraphs: {
+            type: ArrayConstructor;
+            required: true;
+        };
+        noLazy: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        ghost: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        debug: {
+            type: BooleanConstructor;
+            required: false;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        onUpdate?: ((...args: any[]) => any) | undefined;
+    }>, {
+        props: any;
+        emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
+        richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+        lazyParagraphs: import("vue").Ref<any, any>;
+        handleInputEvent: (event: Event) => void;
+        handleFocus: (event: FocusEvent) => void;
+        handleBlur: (event: FocusEvent) => void;
+        richTextGlobalScopedStyleId: string;
+        richTextGlobalScopedStyleDataAttr: string;
+        writeCSS: (cssRules: StyleValue) => string;
+    }, {}, {}, {}, {
+        debug: boolean;
+        noLazy: boolean;
+        ghost: boolean;
+    }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        paragraphs: {
+            type: ArrayConstructor;
+            required: true;
+        };
+        noLazy: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        ghost: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        debug: {
+            type: BooleanConstructor;
+            required: false;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        onUpdate?: ((...args: any[]) => any) | undefined;
+    }>, {
+        props: any;
+        emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
+        richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+        lazyParagraphs: import("vue").Ref<any, any>;
+        handleInputEvent: (event: Event) => void;
+        handleFocus: (event: FocusEvent) => void;
+        handleBlur: (event: FocusEvent) => void;
+        richTextGlobalScopedStyleId: string;
+        richTextGlobalScopedStyleDataAttr: string;
+        writeCSS: (cssRules: StyleValue) => string;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
+        debug: boolean;
+        noLazy: boolean;
+        ghost: boolean;
+    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        paragraphs: {
+            type: ArrayConstructor;
+            required: true;
+        };
+        noLazy: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        ghost: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        debug: {
+            type: BooleanConstructor;
+            required: false;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        onUpdate?: ((...args: any[]) => any) | undefined;
+    }>, {
+        props: any;
+        emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
+        richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+        lazyParagraphs: import("vue").Ref<any, any>;
+        handleInputEvent: (event: Event) => void;
+        handleFocus: (event: FocusEvent) => void;
+        handleBlur: (event: FocusEvent) => void;
+        richTextGlobalScopedStyleId: string;
+        richTextGlobalScopedStyleDataAttr: string;
+        writeCSS: (cssRules: StyleValue) => string;
+    }, {}, {}, {}, {
+        debug: boolean;
+        noLazy: boolean;
+        ghost: boolean;
+    }> | undefined>;
+    richTextDisplayGhostInstance: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        paragraphs: {
+            type: ArrayConstructor;
+            required: true;
+        };
+        noLazy: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        ghost: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        debug: {
+            type: BooleanConstructor;
+            required: false;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        onUpdate?: ((...args: any[]) => any) | undefined;
+    }>, {
+        props: any;
+        emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
+        richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+        lazyParagraphs: import("vue").Ref<any, any>;
+        handleInputEvent: (event: Event) => void;
+        handleFocus: (event: FocusEvent) => void;
+        handleBlur: (event: FocusEvent) => void;
+        richTextGlobalScopedStyleId: string;
+        richTextGlobalScopedStyleDataAttr: string;
+        writeCSS: (cssRules: StyleValue) => string;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
+        debug: boolean;
+        noLazy: boolean;
+        ghost: boolean;
+    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        paragraphs: {
+            type: ArrayConstructor;
+            required: true;
+        };
+        noLazy: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        ghost: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        debug: {
+            type: BooleanConstructor;
+            required: false;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        onUpdate?: ((...args: any[]) => any) | undefined;
+    }>, {
+        props: any;
+        emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
+        richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+        lazyParagraphs: import("vue").Ref<any, any>;
+        handleInputEvent: (event: Event) => void;
+        handleFocus: (event: FocusEvent) => void;
+        handleBlur: (event: FocusEvent) => void;
+        richTextGlobalScopedStyleId: string;
+        richTextGlobalScopedStyleDataAttr: string;
+        writeCSS: (cssRules: StyleValue) => string;
+    }, {}, {}, {}, {
+        debug: boolean;
+        noLazy: boolean;
+        ghost: boolean;
+    }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        paragraphs: {
+            type: ArrayConstructor;
+            required: true;
+        };
+        noLazy: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        ghost: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        debug: {
+            type: BooleanConstructor;
+            required: false;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        onUpdate?: ((...args: any[]) => any) | undefined;
+    }>, {
+        props: any;
+        emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
+        richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+        lazyParagraphs: import("vue").Ref<any, any>;
+        handleInputEvent: (event: Event) => void;
+        handleFocus: (event: FocusEvent) => void;
+        handleBlur: (event: FocusEvent) => void;
+        richTextGlobalScopedStyleId: string;
+        richTextGlobalScopedStyleDataAttr: string;
+        writeCSS: (cssRules: StyleValue) => string;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
+        debug: boolean;
+        noLazy: boolean;
+        ghost: boolean;
+    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        paragraphs: {
+            type: ArrayConstructor;
+            required: true;
+        };
+        noLazy: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        ghost: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        debug: {
+            type: BooleanConstructor;
+            required: false;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        onUpdate?: ((...args: any[]) => any) | undefined;
+    }>, {
+        props: any;
+        emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
+        richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+        lazyParagraphs: import("vue").Ref<any, any>;
+        handleInputEvent: (event: Event) => void;
+        handleFocus: (event: FocusEvent) => void;
+        handleBlur: (event: FocusEvent) => void;
+        richTextGlobalScopedStyleId: string;
+        richTextGlobalScopedStyleDataAttr: string;
+        writeCSS: (cssRules: StyleValue) => string;
+    }, {}, {}, {}, {
+        debug: boolean;
+        noLazy: boolean;
+        ghost: boolean;
+    }> | undefined>;
+    richTextEditorDivRef: import("vue").ComputedRef<HTMLDivElement | undefined>;
+    handleInputEvent: (event: Event) => void;
+    paragraphs: import("vue").Ref<{
+        text: string;
+        format: {
+            [k: string]: unknown;
+        };
+    }[][], RichTextFeature[][] | {
+        text: string;
+        format: {
+            [k: string]: unknown;
+        };
+    }[][]>;
+    visibleParagraphs: import("vue").Ref<{
+        text: string;
+        format: {
+            [k: string]: unknown;
+        };
+    }[][], RichTextFeature[][] | {
+        text: string;
+        format: {
+            [k: string]: unknown;
+        };
+    }[][]>;
+    manipulationState: import("vue").Ref<string, string>;
+    applyFormat: (selectionStart: number, selectionLength: number, format: {
+        [k: string]: unknown;
+    }, select?: boolean) => void;
+    resolveFeatures: (startIndex: number, length: number) => RichTextFeature[][];
+    selection: import("vue").Ref<{
+        start: number;
+        length: number;
+    } | null, {
+        start: number;
+        length: number;
+    } | {
+        start: number;
+        length: number;
+    } | null>;
+    handleKeydownEvent: (event: KeyboardEvent) => void;
+    warningMessage: import("vue").ComputedRef<"Text is too long" | undefined>;
+    focus: import("vue").Ref<boolean, boolean>;
+    handleFocus: () => void;
+    handleBlur: () => void;
+    observer: MutationObserver;
+    RichTextDisplay: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        paragraphs: {
+            type: ArrayConstructor;
+            required: true;
+        };
+        noLazy: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        ghost: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        debug: {
+            type: BooleanConstructor;
+            required: false;
+        };
+    }>, {
+        props: any;
+        emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
+        richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+        lazyParagraphs: import("vue").Ref<any, any>;
+        handleInputEvent: (event: Event) => void;
+        handleFocus: (event: FocusEvent) => void;
+        handleBlur: (event: FocusEvent) => void;
+        richTextGlobalScopedStyleId: string;
+        richTextGlobalScopedStyleDataAttr: string;
+        writeCSS: (cssRules: StyleValue) => string;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], "focus" | "blur" | "update", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        paragraphs: {
+            type: ArrayConstructor;
+            required: true;
+        };
+        noLazy: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        ghost: {
+            type: BooleanConstructor;
+            required: false;
+        };
+        debug: {
+            type: BooleanConstructor;
+            required: false;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        onUpdate?: ((...args: any[]) => any) | undefined;
+    }>, {
+        debug: boolean;
+        noLazy: boolean;
+        ghost: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:focus" | "update:selection" | "update:value" | "update:visible-value" | "update:warning-message")[], "update:focus" | "update:selection" | "update:value" | "update:visible-value" | "update:warning-message", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: ArrayConstructor;
+        required: true;
+    };
+    selection: {
+        type: ObjectConstructor;
+        required: false;
+    };
+    userAgentRichText: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    renderFeatureInlineStyle: {
+        type: FunctionConstructor;
+        required: true;
+    };
+    maxLength: {
+        type: NumberConstructor;
+        required: true;
+    };
+    maxLengthPerLine: {
+        type: NumberConstructor;
+        required: true;
+    };
+    maxLines: {
+        type: NumberConstructor;
+        required: true;
+    };
+    multiline: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:focus"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:selection"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:visible-value"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:warning-message"?: ((...args: any[]) => any) | undefined;
+}>, {
+    multiline: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _sfc_main;
+//# sourceMappingURL=RichText.vue.d.ts.map

package/lib/components/RichText.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RichText.vue.d.ts","sourceRoot":"","sources":["RichText.vue.ts"],"names":[],"mappings":"AACA,OAAO,EAAyC,UAAU,EAA6B,MAAM,KAAK,CAAC;AACnG,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAMjD,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAwCoB,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EA4H9C,CAAA;AACF,eAAe,SAAS,CAAA"}

package/lib/components/RichTextDisplay.vue.d.ts

@@ -0,0 +1,57 @@
+import { StyleValue } from 'vue';
+declare const _sfc_main: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    paragraphs: {
+        type: ArrayConstructor;
+        required: true;
+    };
+    noLazy: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    ghost: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    debug: {
+        type: BooleanConstructor;
+        required: false;
+    };
+}>, {
+    props: any;
+    emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
+    richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    lazyParagraphs: import("vue").Ref<any, any>;
+    handleInputEvent: (event: Event) => void;
+    handleFocus: (event: FocusEvent) => void;
+    handleBlur: (event: FocusEvent) => void;
+    richTextGlobalScopedStyleId: string;
+    richTextGlobalScopedStyleDataAttr: string;
+    writeCSS: (cssRules: StyleValue) => string;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], "focus" | "blur" | "update", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    paragraphs: {
+        type: ArrayConstructor;
+        required: true;
+    };
+    noLazy: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    ghost: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    debug: {
+        type: BooleanConstructor;
+        required: false;
+    };
+}>> & Readonly<{
+    onFocus?: ((...args: any[]) => any) | undefined;
+    onBlur?: ((...args: any[]) => any) | undefined;
+    onUpdate?: ((...args: any[]) => any) | undefined;
+}>, {
+    debug: boolean;
+    noLazy: boolean;
+    ghost: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _sfc_main;
+//# sourceMappingURL=RichTextDisplay.vue.d.ts.map

package/lib/components/RichTextDisplay.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RichTextDisplay.vue.d.ts","sourceRoot":"","sources":["RichTextDisplay.vue.ts"],"names":[],"mappings":"AAEA,OAAO,EAAO,UAAU,EAAsB,MAAM,KAAK,CAAC;AAK1D,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;8BAgCkB,KAAK;yBAIV,UAAU;wBAGX,UAAU;;;yBAYT,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;4EA4BpC,CAAA;AACF,eAAe,SAAS,CAAA"}