@quadrats/common 0.5.1 → 0.5.10

package/blockquote/createBlockquote.js

@@ -1,11 +1,27 @@
-import { isNodesTypeIn, toggleNodesType, Element, normalizeOnlyInlineOrTextInChildren } from '@quadrats/core';
+import { isNodesTypeIn, toggleNodesType, Editor, Transforms, createParagraphElement, Element, normalizeOnlyInlineOrTextInChildren } from '@quadrats/core';
 import { BLOCKQUOTE_TYPE } from './constants.js';
 
 function createBlockquote({ type = BLOCKQUOTE_TYPE } = {}) {
     return {
         type,
         isSelectionInBlockquote: editor => isNodesTypeIn(editor, [type]),
-        toggleBlockquote: editor => toggleNodesType(editor, type),
+        toggleBlockquote: (editor) => {
+            const actived = isNodesTypeIn(editor, [type]);
+            toggleNodesType(editor, type);
+            if (!actived) {
+                if (editor.selection) {
+                    // Select to line end
+                    const originPoint = Editor.point(editor, editor.selection.focus);
+                    Transforms.move(editor, { unit: 'line', edge: 'end' });
+                    Transforms.collapse(editor, { edge: 'end' });
+                    // Only last block add paragraph automatically
+                    if (!Editor.next(editor)) {
+                        Transforms.insertNodes(editor, [createParagraphElement()]);
+                    }
+                    Transforms.select(editor, originPoint);
+                }
+            }
+        },
         with(editor) {
             const { normalizeNode } = editor;
             editor.normalizeNode = (entry) => {

package/blockquote/index.cjs.js

@@ -10,7 +10,23 @@ function createBlockquote({ type = BLOCKQUOTE_TYPE } = {}) {
     return {
         type,
         isSelectionInBlockquote: editor => core.isNodesTypeIn(editor, [type]),
-        toggleBlockquote: editor => core.toggleNodesType(editor, type),
+        toggleBlockquote: (editor) => {
+            const actived = core.isNodesTypeIn(editor, [type]);
+            core.toggleNodesType(editor, type);
+            if (!actived) {
+                if (editor.selection) {
+                    // Select to line end
+                    const originPoint = core.Editor.point(editor, editor.selection.focus);
+                    core.Transforms.move(editor, { unit: 'line', edge: 'end' });
+                    core.Transforms.collapse(editor, { edge: 'end' });
+                    // Only last block add paragraph automatically
+                    if (!core.Editor.next(editor)) {
+                        core.Transforms.insertNodes(editor, [core.createParagraphElement()]);
+                    }
+                    core.Transforms.select(editor, originPoint);
+                }
+            }
+        },
         with(editor) {
             const { normalizeNode } = editor;
             editor.normalizeNode = (entry) => {

package/blockquote/typings.d.ts

@@ -1,7 +1,7 @@
 import { Editor, QuadratsElement, Withable, WithElementType } from '@quadrats/core';
 export interface BlockquoteElement extends QuadratsElement, WithElementType {
 }
-export interface Blockquote extends WithElementType, Withable {
-    isSelectionInBlockquote(editor: Editor): boolean;
-    toggleBlockquote(editor: Editor): void;
+export interface Blockquote<T extends Editor = Editor> extends WithElementType, Withable {
+    isSelectionInBlockquote(editor: T): boolean;
+    toggleBlockquote(editor: T): void;
 }

package/bold/createBold.d.ts

@@ -1 +1 @@
-export declare const createBold: (variant?: string | undefined) => ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;
+export declare const createBold: (variant?: string | undefined) => ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark<import("slate").BaseEditor>;

package/divider/typings.d.ts

@@ -2,7 +2,7 @@ import { Editor, QuadratsElement, Text, Withable, WithElementType } from '@quadr
 export interface DividerElement extends QuadratsElement, WithElementType {
     children: [Text];
 }
-export interface Divider extends WithElementType, Withable {
+export interface Divider<T extends Editor = Editor> extends WithElementType, Withable {
     createDividerElement(): DividerElement;
-    insertDivider(editor: Editor): void;
+    insertDivider(editor: T): void;
 }

package/embed/strategies/podcast-apple/index.cjs.js

@@ -6,17 +6,18 @@ Object.defineProperty(exports, '__esModule', { value: true });
 const PodcastAppleEmbedStrategy = {
     serialize: (embedCode) => {
         var _a, _b;
-        const result = (_b = (_a = /^https:\/\/embed.podcasts.apple.com\/[\w-]*\/podcast\/[\S]*\/id([\d]*)/i.exec(embedCode)) !== null && _a !== void 0 ? _a : /^https:\/\/embed.podcasts.apple.com\/[\w-]*\/podcast\/id([\d]*)/i.exec(embedCode)) !== null && _b !== void 0 ? _b : /^https:\/\/podcasts.apple.com\/[\w-]*\/podcast\/[\S]*\/id([\d]*)/i.exec(embedCode);
+        const result = (_b = (_a = /^https:\/\/embed.podcasts.apple.com\/([\w-]*)\/podcast\/[\S]*\/id([\d]*)/i.exec(embedCode)) !== null && _a !== void 0 ? _a : /^https:\/\/embed.podcasts.apple.com\/([\w-]*)\/podcast\/id([\d]*)/i.exec(embedCode)) !== null && _b !== void 0 ? _b : /^https:\/\/podcasts.apple.com\/([\w-]*)\/podcast\/[\S]*\/id([\d]*)/i.exec(embedCode);
         if (result) {
-            const [, contextId] = result;
+            const [, language, contextId] = result;
             return {
                 embedType: 'podcast-apple',
+                language,
                 contextId,
             };
         }
     },
-    deserialize: (data) => `https://embed.podcasts.apple.com/us/podcast/id${data.contextId}`,
-    isElementDataValid: (data) => typeof data.contextId === 'string' && !!(data.contextId),
+    deserialize: data => { var _a; return `https://embed.podcasts.apple.com/${(_a = data.language) !== null && _a !== void 0 ? _a : 'us'}/podcast/id${data.contextId}`; },
+    isElementDataValid: data => typeof data.contextId === 'string' && !!(data.contextId),
 };
 
 exports.PodcastAppleEmbedStrategy = PodcastAppleEmbedStrategy;

package/embed/strategies/podcast-apple/index.d.ts

@@ -2,6 +2,7 @@ import { EmbedElement, EmbedStrategy } from '@quadrats/common/embed';
 export declare type PodcastAppleEmbedType = 'podcast-apple';
 export declare type PodcastAppleEmbedElementData = {
     embedType: PodcastAppleEmbedType;
+    language?: string;
     contextId: string;
 };
 export declare type PodcastAppleEmbedElement = EmbedElement & PodcastAppleEmbedElementData;

package/embed/strategies/podcast-apple/index.js

@@ -2,17 +2,18 @@
 const PodcastAppleEmbedStrategy = {
     serialize: (embedCode) => {
         var _a, _b;
-        const result = (_b = (_a = /^https:\/\/embed.podcasts.apple.com\/[\w-]*\/podcast\/[\S]*\/id([\d]*)/i.exec(embedCode)) !== null && _a !== void 0 ? _a : /^https:\/\/embed.podcasts.apple.com\/[\w-]*\/podcast\/id([\d]*)/i.exec(embedCode)) !== null && _b !== void 0 ? _b : /^https:\/\/podcasts.apple.com\/[\w-]*\/podcast\/[\S]*\/id([\d]*)/i.exec(embedCode);
+        const result = (_b = (_a = /^https:\/\/embed.podcasts.apple.com\/([\w-]*)\/podcast\/[\S]*\/id([\d]*)/i.exec(embedCode)) !== null && _a !== void 0 ? _a : /^https:\/\/embed.podcasts.apple.com\/([\w-]*)\/podcast\/id([\d]*)/i.exec(embedCode)) !== null && _b !== void 0 ? _b : /^https:\/\/podcasts.apple.com\/([\w-]*)\/podcast\/[\S]*\/id([\d]*)/i.exec(embedCode);
         if (result) {
-            const [, contextId] = result;
+            const [, language, contextId] = result;
             return {
                 embedType: 'podcast-apple',
+                language,
                 contextId,
             };
         }
     },
-    deserialize: (data) => `https://embed.podcasts.apple.com/us/podcast/id${data.contextId}`,
-    isElementDataValid: (data) => typeof data.contextId === 'string' && !!(data.contextId),
+    deserialize: data => { var _a; return `https://embed.podcasts.apple.com/${(_a = data.language) !== null && _a !== void 0 ? _a : 'us'}/podcast/id${data.contextId}`; },
+    isElementDataValid: data => typeof data.contextId === 'string' && !!(data.contextId),
 };
 
 export { PodcastAppleEmbedStrategy };

package/embed/typings.d.ts

@@ -20,7 +20,7 @@ export interface EmbedStrategy<EmbedData extends Record<string, unknown>, Render
     readonly isElementDataValid: (data: Record<keyof EmbedData, unknown>) => boolean;
 }
 export declare type EmbedStrategies<Provider extends string> = Record<Provider, EmbedStrategy<any, any>>;
-export interface Embed<P extends string> extends WithElementType, Withable {
+export interface Embed<P extends string, T extends Editor = Editor> extends WithElementType, Withable {
     strategies: EmbedStrategies<P>;
-    insertEmbed(editor: Editor, providers: P[], embedCode: string, defaultNode?: Node | string): void;
+    insertEmbed(editor: T, providers: P[], embedCode: string, defaultNode?: Node | string): void;
 }

package/file-uploader/createFileUploader.d.ts

@@ -1,5 +1,6 @@
+import { Editor } from '@quadrats/core';
 import { FileUploader } from './typings';
 export interface CreateFileUploaderOptions {
     type?: string;
 }
-export declare function createFileUploader(options?: CreateFileUploaderOptions): FileUploader;
+export declare function createFileUploader(options?: CreateFileUploaderOptions): FileUploader<Editor>;

package/file-uploader/createFileUploader.js

@@ -74,8 +74,6 @@ function createFileUploader(options = {}) {
         createFileUploaderElement,
         upload,
         with(editor) {
-            // const { isVoid } = editor;
-            // editor.isVoid = element => element.type === type || isVoid(element);
             return editor;
         },
     };

package/file-uploader/index.cjs.js

@@ -128,8 +128,6 @@ function createFileUploader(options = {}) {
         createFileUploaderElement,
         upload,
         with(editor) {
-            // const { isVoid } = editor;
-            // editor.isVoid = element => element.type === type || isVoid(element);
             return editor;
         },
     };

package/file-uploader/typings.d.ts

@@ -30,8 +30,8 @@ export interface FileUploaderCreateFileUploaderElementOptions {
     getUrl: FileUploaderGetUrl;
 }
 export declare type FileUploaderUploadOptions = FileUploaderCreateFileUploaderElementOptions & GetFilesFromInputOptions & TransformsInsertNodesOptions;
-export interface FileUploader extends Withable {
+export interface FileUploader<T extends Editor = Editor> extends Withable {
     type: string;
-    createFileUploaderElement(editor: Editor, file: File, options: FileUploaderCreateFileUploaderElementOptions): Promise<FileUploaderElement | undefined>;
-    upload(editor: Editor, options: FileUploaderUploadOptions): Promise<void>;
+    createFileUploaderElement(editor: T, file: File, options: FileUploaderCreateFileUploaderElementOptions): Promise<FileUploaderElement | undefined>;
+    upload(editor: T, options: FileUploaderUploadOptions): Promise<void>;
 }

package/footnote/typings.d.ts

@@ -18,11 +18,11 @@ export interface FootnoteWrapFootnoteOptions extends Omit<TransformsWrapNodesOpt
 export interface FootnoteUpsertFootnoteOptions {
     at?: Range;
 }
-export interface Footnote extends WithElementType, Withable {
-    getFootnoteText(editor: Editor): string;
-    isSelectionInFootnote(editor: Editor): boolean;
-    unwrapFootnote(editor: Editor, options?: FootnoteUnwrapFootnoteOptions): void;
-    updateFootnoteIndex(editor: Editor, options?: FootnoteUpdateFootnoteIndexOptions): void;
-    upsertFootnoteAndUpdateIndex(editor: Editor, footnote: string, options?: FootnoteUpsertFootnoteOptions): void;
-    wrapFootnote(editor: Editor, footnote: string, options?: FootnoteWrapFootnoteOptions): void;
+export interface Footnote<T extends Editor = Editor> extends WithElementType, Withable {
+    getFootnoteText(editor: T): string;
+    isSelectionInFootnote(editor: T): boolean;
+    unwrapFootnote(editor: T, options?: FootnoteUnwrapFootnoteOptions): void;
+    updateFootnoteIndex(editor: T, options?: FootnoteUpdateFootnoteIndexOptions): void;
+    upsertFootnoteAndUpdateIndex(editor: T, footnote: string, options?: FootnoteUpsertFootnoteOptions): void;
+    wrapFootnote(editor: T, footnote: string, options?: FootnoteWrapFootnoteOptions): void;
 }

package/heading/typings.d.ts

@@ -9,8 +9,8 @@ export interface WithEnabledHeadingLevels<L extends HeadingLevel> {
      */
     enabledLevels: ReadonlyArray<L>;
 }
-export interface Heading<L extends HeadingLevel> extends WithElementType, Withable, WithEnabledHeadingLevels<L> {
-    getHeadingNodes(editor: Editor, level: L, options?: GetNodesOptions): Generator<NodeEntry<Node>>;
-    isSelectionInHeading(editor: Editor, level: L, options?: GetNodesOptions): boolean;
-    toggleHeadingNodes(editor: Editor, level: L, defaultType?: string): void;
+export interface Heading<L extends HeadingLevel, T extends Editor = Editor> extends WithElementType, Withable, WithEnabledHeadingLevels<L> {
+    getHeadingNodes(editor: T, level: L, options?: GetNodesOptions): Generator<NodeEntry<Node>>;
+    isSelectionInHeading(editor: T, level: L, options?: GetNodesOptions): boolean;
+    toggleHeadingNodes(editor: T, level: L, defaultType?: string): void;
 }

package/highlight/createHighlight.d.ts

@@ -1 +1 @@
-export declare const createHighlight: (variant?: string | undefined) => ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;
+export declare const createHighlight: (variant?: string | undefined) => ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark<import("slate").BaseEditor>;

package/image/typings.d.ts

@@ -37,7 +37,7 @@ export declare type ImageHostingResolvers<Hosting extends string> = Record<Hosti
 export declare type ImageSizeSteps = ReadonlyArray<number>;
 export declare type ImageGetAboveImageFigureOptions = GetAboveByTypesOptions;
 export declare type ImageGetAboveImageCaptionOptions = GetAboveByTypesOptions;
-export interface Image<Hosting extends string> extends Withable {
+export interface Image<Hosting extends string, T extends Editor = Editor> extends Withable {
     /**
      * An object which keys are `figure`, `image`, 'caption` and values are the corresponding element types.
      */
@@ -51,15 +51,15 @@ export interface Image<Hosting extends string> extends Withable {
      */
     sizeSteps?: ImageSizeSteps;
     isImageUrl(url: string): boolean;
-    getAboveImageFigure(editor: Editor, options?: ImageGetAboveImageFigureOptions): NodeEntry<ImageFigureElement> | undefined;
-    getAboveImageCaption(editor: Editor, options?: ImageGetAboveImageCaptionOptions): NodeEntry<ImageCaptionElement> | undefined;
-    isSelectionInImage(editor: Editor): boolean;
-    isSelectionInImageCaption(editor: Editor): boolean;
-    isCollapsedOnImage(editor: Editor): boolean;
+    getAboveImageFigure(editor: T, options?: ImageGetAboveImageFigureOptions): NodeEntry<ImageFigureElement> | undefined;
+    getAboveImageCaption(editor: T, options?: ImageGetAboveImageCaptionOptions): NodeEntry<ImageCaptionElement> | undefined;
+    isSelectionInImage(editor: T): boolean;
+    isSelectionInImageCaption(editor: T): boolean;
+    isCollapsedOnImage(editor: T): boolean;
     createImageElement(src: string, hosting?: Hosting): ImageFigureElement;
-    insertImage(editor: Editor, src: string, options?: {
+    insertImage(editor: T, src: string, options?: {
         hosting?: Hosting;
         at?: Location;
     }): void;
-    resizeImage(editor: Editor, entry: NodeEntry<QuadratsElement>, width: number): void;
+    resizeImage(editor: T, entry: NodeEntry<QuadratsElement>, width: number): void;
 }

package/input-block/typings.d.ts

@@ -3,9 +3,9 @@ import { InputWidgetConfig } from '@quadrats/common/input-widget';
 export interface InputBlockElement extends QuadratsElement, InputWidgetConfig {
     type: string;
 }
-export interface InputBlock extends Withable {
+export interface InputBlock<T extends Editor = Editor> extends Withable {
     type: string;
-    start(editor: Editor, config: InputWidgetConfig): void;
-    remove(editor: Editor, entry: NodeEntry<InputBlockElement>, foucs: VoidFunction): void;
+    start(editor: T, config: InputWidgetConfig): void;
+    remove(editor: T, entry: NodeEntry<InputBlockElement>, foucs: VoidFunction): void;
     confirm(element: InputBlockElement, value: string, remove: VoidFunction): void;
 }

package/italic/createItalic.d.ts

@@ -1 +1 @@
-export declare const createItalic: (variant?: string | undefined) => ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;
+export declare const createItalic: (variant?: string | undefined) => ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark<import("slate").BaseEditor>;

package/link/typings.d.ts

@@ -10,18 +10,18 @@ export declare type LinkWrapLinkOptions = Omit<TransformsWrapNodesOptions, 'spli
 export interface LinkUpsertLinkOptions {
     at?: Range;
 }
-export interface Link extends WithElementType, Withable {
+export interface Link<T extends Editor = Editor> extends WithElementType, Withable {
     isUrl(value: string): boolean;
     /**
      * To get the first previous text which is url and its range.
      */
-    getFirstPrevTextAsUrlAndRange(editor: Editor, at: Location): {
+    getFirstPrevTextAsUrlAndRange(editor: T, at: Location): {
         url: string;
         at: Range;
     } | undefined;
-    isSelectionInLink(editor: Editor): boolean;
-    insertLink(editor: Editor, url: string, options?: LinkInsertLinkOptions): void;
-    unwrapLink(editor: Editor, options?: LinkUnwrapLinkOptions): void;
-    wrapLink(editor: Editor, url: string, options?: LinkWrapLinkOptions): void;
-    upsertLink(editor: Editor, url: string, options?: LinkUpsertLinkOptions): void;
+    isSelectionInLink(editor: T): boolean;
+    insertLink(editor: T, url: string, options?: LinkInsertLinkOptions): void;
+    unwrapLink(editor: T, options?: LinkUnwrapLinkOptions): void;
+    wrapLink(editor: T, url: string, options?: LinkWrapLinkOptions): void;
+    upsertLink(editor: T, url: string, options?: LinkUpsertLinkOptions): void;
 }

package/list/typings.d.ts

@@ -12,30 +12,30 @@ export interface ListAboveListAndItem {
 export interface ListGetAboveListEntriesOptions {
     at?: Location;
 }
-export interface List extends Withable {
+export interface List<T extends Editor = Editor> extends Withable {
     /**
      * An object which keys are `ul`, `ol`, `li` and values are the corresponding element types.
      */
     types: ListTypes;
     isListElement(node: Node): node is QuadratsElement;
     isListItemElement(node: Node): node is QuadratsElement;
-    isSelectionInList(editor: Editor, listTypeKey: ListRootTypeKey): boolean;
+    isSelectionInList(editor: T, listTypeKey: ListRootTypeKey): boolean;
     /**
      * If expanded, get the list wrapping the location.
      */
-    getAboveListAndItem(editor: Editor, options?: ListGetAboveListEntriesOptions): ListAboveListAndItem | undefined;
-    unwrapList(editor: Editor): void;
-    toggleList(editor: Editor, listTypeKey: ListRootTypeKey, defaultType?: string): void;
+    getAboveListAndItem(editor: T, options?: ListGetAboveListEntriesOptions): ListAboveListAndItem | undefined;
+    unwrapList(editor: T): void;
+    toggleList(editor: T, listTypeKey: ListRootTypeKey, defaultType?: string): void;
     /**
      * Increase the depth of the first item in the location if increasable.
      */
-    increaseListItemDepth(editor: Editor, entries: ListAboveListAndItem): void;
+    increaseListItemDepth(editor: T, entries: ListAboveListAndItem): void;
     /**
      * Decrease the depth of the first item in the location if decreasable.
      */
-    decreaseListItemDepth(editor: Editor, entries: ListAboveListAndItem): void;
+    decreaseListItemDepth(editor: T, entries: ListAboveListAndItem): void;
     /**
      * Unwrap the list if at root, or decrease the depth of list item.
      */
-    decreaseListItemDepthOrUnwrapIfNeed(editor: Editor, entries: ListAboveListAndItem): void;
+    decreaseListItemDepthOrUnwrapIfNeed(editor: T, entries: ListAboveListAndItem): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quadrats/common",
-  "version": "0.5.1",
+  "version": "0.5.10",
   "description": "",
   "author": "Rytass",
   "homepage": "https://github.com/Quadrats/quadrats#readme",
@@ -18,7 +18,7 @@
     "url": "https://github.com/Quadrats/quadrats/issues"
   },
   "dependencies": {
-    "@quadrats/core": "^0.5.1",
+    "@quadrats/core": "^0.5.9",
     "@quadrats/locales": "^0.5.0",
     "@quadrats/utils": "^0.5.0"
   }

package/read-more/typings.d.ts

@@ -2,7 +2,7 @@ import { Editor, QuadratsElement, Text, Withable, WithElementType } from '@quadr
 export interface ReadMoreElement extends QuadratsElement, WithElementType {
     children: [Text];
 }
-export interface ReadMore extends WithElementType, Withable {
+export interface ReadMore<T extends Editor = Editor> extends WithElementType, Withable {
     createReadMoreElement(): ReadMoreElement;
-    insertReadMore(editor: Editor): void;
+    insertReadMore(editor: T): void;
 }

package/strikethrough/createStrikethrough.d.ts

@@ -1 +1 @@
-export declare const createStrikethrough: (variant?: string | undefined) => ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;
+export declare const createStrikethrough: (variant?: string | undefined) => ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark<import("slate").BaseEditor>;

package/toggle-mark/typings.d.ts

@@ -1,5 +1,5 @@
 import { Editor, WithMarkType } from '@quadrats/core';
-export interface ToggleMark extends WithMarkType {
-    isToggleMarkActive(editor: Editor): boolean;
-    toggleMark(editor: Editor): void;
+export interface ToggleMark<T extends Editor = Editor> extends WithMarkType {
+    isToggleMarkActive(editor: T): boolean;
+    toggleMark(editor: T): void;
 }

package/underline/createUnderline.d.ts

@@ -1 +1 @@
-export declare const createUnderline: (variant?: string | undefined) => ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;
+export declare const createUnderline: (variant?: string | undefined) => ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark<import("slate").BaseEditor>;