@edifice.io/tiptap-extensions 1.5.16-develop-rc.2 → 1.7.4-develop-pedago.20241211160712

package/src/attachment/attachment.ts

@@ -1,113 +0,0 @@
-import { Node } from '@tiptap/core';
-
-export interface AttachmentOptions {
-  HTMLAttributes: Record<string, string>;
-}
-
-declare module '@tiptap/core' {
-  interface Commands<ReturnType> {
-    attachment: {
-      setAttachment: (attachment) => ReturnType;
-    };
-  }
-}
-
-export const Attachment = Node.create<AttachmentOptions>({
-  name: 'attachments',
-  content: '',
-  marks: '',
-  group: 'block',
-  selectable: true,
-  atom: true,
-  draggable: true,
-
-  addOptions() {
-    return {
-      HTMLAttributes: {
-        class: 'attachments',
-      },
-    };
-  },
-
-  parseHTML() {
-    return [{ tag: 'div[class=attachments]' }];
-  },
-
-  renderHTML({ HTMLAttributes }) {
-    const links = HTMLAttributes.links;
-
-    const renderedLinks = links.map((el) => {
-      return [
-        'a',
-        {
-          name: el.name,
-          href: el.href,
-          documentId: el.documentId,
-          dataContentType: el.dataContentType,
-        },
-        el.name,
-      ];
-    });
-
-    return ['div', this.options.HTMLAttributes, ...renderedLinks];
-  },
-
-  addAttributes() {
-    return {
-      links: {
-        default: [],
-        parseHTML: (element) => {
-          const links = element.getElementsByTagName('a');
-          const parsedLinks = [];
-
-          for (let i = 0; i < links.length; i++) {
-            const link = links[i];
-            const href = link.getAttribute('href');
-            const name = link.textContent;
-            const regexResult = href.match(/([^/]+$)/);
-            const documentId =
-              link.getAttribute('data-document-id') ||
-              (regexResult && regexResult[0]);
-            const dataContentType = link.getAttribute('data-content-type');
-
-            parsedLinks.push({
-              href,
-              name,
-              documentId,
-              dataContentType,
-            });
-          }
-
-          return parsedLinks;
-        },
-        renderHTML: (attributes) => {
-          return {
-            links: attributes.links.map((link) => ({
-              href: link.href,
-              name: link.name,
-              documentId: link.documentId,
-              dataContentType: link.dataContentType,
-            })),
-          };
-        },
-      },
-    };
-  },
-
-  addCommands() {
-    return {
-      setAttachment:
-        (
-          attrs = {
-            dataContentType: '',
-            name: '',
-            documentId: '',
-            href: '',
-          },
-        ) =>
-        ({ chain }) => {
-          return chain().insertContent({ type: this.name, attrs }).run();
-        },
-    };
-  },
-});

package/src/attachment/index.ts

@@ -1,5 +0,0 @@
-import { Attachment } from './attachment';
-
-export * from './attachment';
-
-export default Attachment;

package/src/audio/audio.ts

@@ -1,81 +0,0 @@
-import { mergeAttributes, Node } from '@tiptap/core';
-
-export interface AudioOptions {
-  url: string;
-  HTMLAttributes: Record<string, any>;
-}
-
-declare module '@tiptap/core' {
-  interface Commands<ReturnType> {
-    audio: {
-      /**
-       * Set a audio node
-       * @param options.updateSelection set to true will select the newly inserted content
-       */
-      setAudio: (
-        id: string,
-        src: string,
-        options?: { updateSelection: boolean },
-      ) => ReturnType;
-    };
-  }
-}
-
-export const Audio = Node.create({
-  name: 'audio',
-
-  group: 'block',
-
-  addAttributes() {
-    return {
-      src: {
-        default: null,
-        parseHTML: (el: any) => (el as HTMLSpanElement).getAttribute('src'),
-        renderHTML: (attrs: any) => ({ src: attrs.src }),
-      },
-      documentId: {
-        default: '',
-        renderHTML: (attributes: any) => {
-          return { 'data-document-id': attributes.documentId };
-        },
-        parseHTML: (element: any) => element.getAttribute('data-document-id'),
-      },
-    };
-  },
-
-  parseHTML() {
-    return [
-      {
-        tag: 'div.audio-wrapper>audio,audio',
-        getAttrs: (el: any) => ({
-          src: (el as HTMLAudioElement).getAttribute('src'),
-        }),
-      },
-    ];
-  },
-
-  renderHTML({ HTMLAttributes }) {
-    return [
-      'div',
-      { class: 'audio-wrapper' },
-      ['audio', mergeAttributes(HTMLAttributes)],
-    ];
-  },
-
-  addCommands() {
-    return {
-      setAudio:
-        (id, src, options) =>
-        ({ commands, state }) => {
-          return commands.insertContentAt(
-            state.selection,
-            `<audio 
-              src="${src}" 
-              controls preload="none"
-              data-document-id="${id}"></audio>`,
-            options,
-          );
-        },
-    };
-  },
-});

package/src/audio/index.ts

@@ -1,5 +0,0 @@
-import { Audio } from './audio';
-
-export * from './audio';
-
-export default Audio;

package/src/font-size/font-size.ts

@@ -1,74 +0,0 @@
-import '@tiptap/extension-text-style';
-
-import { Extension } from '@tiptap/core';
-
-export type FontSizeOptions = {
-  types: string[];
-};
-
-declare module '@tiptap/core' {
-  interface Commands<ReturnType> {
-    fontSize: {
-      /**
-       * Set the font size
-       */
-      setFontSize: (fontSize: string) => ReturnType;
-      /**
-       * Unset the font size
-       */
-      unsetFontSize: () => ReturnType;
-    };
-  }
-}
-
-export const FontSize = Extension.create<FontSizeOptions>({
-  name: 'fontSize',
-
-  addOptions() {
-    return {
-      types: ['textStyle'],
-    };
-  },
-
-  addGlobalAttributes() {
-    return [
-      {
-        types: this.options.types,
-        attributes: {
-          fontSize: {
-            default: null,
-            parseHTML: (element) =>
-              element.style.fontSize?.replace(/['"]+/g, ''),
-            renderHTML: (attributes) => {
-              if (!attributes.fontSize) {
-                return {};
-              }
-
-              return {
-                style: `font-size: ${attributes.fontSize}`,
-              };
-            },
-          },
-        },
-      },
-    ];
-  },
-
-  addCommands() {
-    return {
-      setFontSize:
-        (fontSize) =>
-        ({ chain }) => {
-          return chain().setMark('textStyle', { fontSize }).run();
-        },
-      unsetFontSize:
-        () =>
-        ({ chain }) => {
-          return chain()
-            .setMark('textStyle', { fontSize: null })
-            .removeEmptyTextStyle()
-            .run();
-        },
-    };
-  },
-});

package/src/font-size/index.ts

@@ -1,5 +0,0 @@
-import { FontSize } from './font-size';
-
-export * from './font-size';
-
-export default FontSize;

package/src/heading/heading.ts

@@ -1,90 +0,0 @@
-import { mergeAttributes } from '@tiptap/core';
-import { Heading } from '@tiptap/extension-heading';
-import '@tiptap/extension-text-style';
-
-export declare type Level = 1 | 2;
-
-interface Options {
-  levels: Level[];
-  HTMLAttributes: Record<string, any>;
-}
-
-declare module '@tiptap/core' {
-  interface Commands<ReturnType> {
-    customHeading: {
-      /**
-       * Apply Heading Level
-       */
-      setCustomHeading: (attributes: { level: Level }) => ReturnType;
-    };
-  }
-}
-
-export const CustomHeading = Heading.extend<Options>({
-  name: 'customHeading',
-
-  addOptions() {
-    return {
-      ...this.parent?.(),
-      HTMLAttributes: {},
-    };
-  },
-
-  parseHTML() {
-    return this.options.levels.map((level: Level) => ({
-      tag: `h${level}`,
-      attrs: { level },
-    }));
-  },
-
-  renderHTML({ node, HTMLAttributes }) {
-    const hasLevel = this.options.levels.includes(node.attrs.level);
-    const level = hasLevel ? node.attrs.level : this.options.levels[0];
-
-    return [
-      `h${level}`,
-      mergeAttributes(this.options.HTMLAttributes, HTMLAttributes),
-      0,
-    ];
-  },
-
-  addCommands() {
-    return {
-      setCustomHeading:
-        (attributes) =>
-        ({ tr, dispatch, commands }) => {
-          if (!this.options.levels.includes(attributes.level)) {
-            return false;
-          }
-
-          const { selection } = tr;
-          const { from, to } = selection;
-
-          tr.doc.nodesBetween(from, to, (node, pos) => {
-            if (node.isBlock && from >= pos && to <= pos + node.nodeSize) {
-              /* get node content and iterate through */
-              node.content.forEach((content) => {
-                /* get content marks and iterate through */
-                content.marks.forEach((mark) => {
-                  /* find textStyle mark and if has fontSize attrs */
-                  if (
-                    mark.type.name === 'textStyle' &&
-                    mark.attrs['fontSize'] &&
-                    mark.attrs['fontSize'] !== null
-                  ) {
-                    /* remove any fontSize attr to reset heading style */
-                    tr = tr.removeMark(pos, pos + node.nodeSize, mark.type);
-                  }
-                });
-              });
-            }
-          });
-
-          if (dispatch) {
-            dispatch(tr);
-          }
-          return commands.setHeading({ level: attributes.level });
-        },
-    };
-  },
-});

package/src/heading/index.ts

@@ -1,5 +0,0 @@
-import { CustomHeading } from './heading';
-
-export * from './heading';
-
-export default CustomHeading;

package/src/highlight/highlight.ts

@@ -1,27 +0,0 @@
-import Highlight from '@tiptap/extension-highlight';
-
-export const CustomHighlight = Highlight.extend({
-  name: 'customHighlight',
-
-  addOptions() {
-    return {
-      ...this.parent?.(),
-      multicolor: true,
-      HTMLAttributes: {},
-    };
-  },
-
-  parseHTML() {
-    return [
-      {
-        ...this.parent?.(),
-        style: 'background-color',
-        getAttrs: (style) => {
-          return {
-            color: style,
-          };
-        },
-      },
-    ];
-  },
-});

package/src/highlight/index.ts

@@ -1,5 +0,0 @@
-import { CustomHighlight } from './highlight';
-
-export * from './highlight';
-
-export default CustomHighlight;

package/src/hyperlink/hyperlink.ts

@@ -1,92 +0,0 @@
-import { Link } from '@tiptap/extension-link';
-
-/** Our own model of an hyperlink in a rich document. */
-export type HyperlinkAttributes = {
-  href: string | null;
-  target: '_blank' | null;
-  title: string | null;
-  text: string | null;
-};
-
-declare module '@tiptap/core' {
-  interface Commands<ReturnType> {
-    hyperlink: {
-      /**
-       * Set an hyperlink mark
-       */
-      setLink: (attributes: Partial<HyperlinkAttributes>) => ReturnType;
-      /**
-       * Toggle an hyperlink mark
-       */
-      toggleLink: (attributes: {
-        href: string;
-        target?: string | null;
-      }) => ReturnType;
-      /**
-       * Unset an hyperlink mark
-       */
-      unsetLink: () => ReturnType;
-    };
-  }
-}
-
-/**
- * Hyperlink (external links), extends `Link` extension from TipTap.
- *
- * Links to external resources MUST NOT have a `data-id` nor a `data-app-prefix` attribute.
- * The `target` attribute has to be sanitized, so it is overriden.
- */
-export const Hyperlink = Link.extend({
-  name: 'hyperlink',
-
-  parseHTML() {
-    return [
-      {
-        tag: 'a[href]:not([href *= "javascript:" i])',
-        // Be sure no data-id and data-app-prefix attribute exists :
-        // it would then be an Linker, not an Hyperlink !
-        getAttrs: (node: HTMLAnchorElement) => {
-          // See https://prosemirror.net/docs/ref/version/0.18.0.html#model.ParseRule.getAttrs
-          if (
-            node.getAttribute('data-id') &&
-            node.getAttribute('data-app-prefix')
-          )
-            return false;
-        },
-      },
-    ];
-  },
-
-  addOptions() {
-    return {
-      ...this.parent?.(),
-      openOnClick: false,
-      HTMLAttributes: {
-        ...this.parent?.().HTMLAttributes,
-        target: null,
-      },
-    };
-  },
-
-  /* Manage `title` and `target` attributes. */
-  addAttributes() {
-    return {
-      // Preserve attributes of parent extension...
-      ...this.parent?.(),
-      // ...then add or override the following :
-      //------------------
-      target: {
-        default: this.options.HTMLAttributes.target,
-        // Sanitize target value
-        parseHTML: (element) =>
-          element.getAttribute('target') !== '_blank' ? null : '_blank',
-        renderHTML: (attributes) => ({
-          target: attributes['target'],
-        }),
-      },
-      title: {
-        default: this.options.HTMLAttributes.title,
-      },
-    };
-  },
-});

package/src/hyperlink/index.ts

@@ -1,5 +0,0 @@
-import { Hyperlink } from './hyperlink';
-
-export * from './hyperlink';
-
-export default Hyperlink;

package/src/iframe/iframe.ts

@@ -1,112 +0,0 @@
-import { Node } from '@tiptap/core';
-
-export interface IframeOptions {
-  allowFullscreen: boolean;
-  HTMLAttributes: {
-    [key: string]: any;
-  };
-}
-
-declare module '@tiptap/core' {
-  interface Commands<ReturnType> {
-    iframe: {
-      /**
-       * Add an iframe
-       */
-      setIframe: (options: { src: string }) => ReturnType;
-    };
-  }
-}
-
-export const Iframe = Node.create<IframeOptions>({
-  name: 'iframe',
-  group: 'block',
-  atom: true,
-  draggable: true,
-
-  addOptions() {
-    return {
-      allowFullscreen: true,
-      HTMLAttributes: {
-        class: 'iframe-wrapper',
-      },
-    };
-  },
-
-  addAttributes() {
-    return {
-      src: {
-        default: null,
-      },
-      frameborder: {
-        default: 0,
-      },
-      allowfullscreen: {
-        default: this.options.allowFullscreen,
-        parseHTML: () => this.options.allowFullscreen,
-      },
-      width: {
-        renderHTML: (attributes) => {
-          return attributes.width
-            ? {
-                width:
-                  attributes.width === '100%'
-                    ? '100%'
-                    : parseInt(attributes.width),
-              }
-            : {};
-        },
-        parseHTML: (element) => element.getAttribute('width'),
-      },
-      height: {
-        renderHTML: (attributes) => {
-          return attributes.height
-            ? {
-                height: parseInt(attributes.height),
-              }
-            : {};
-        },
-        parseHTML: (element) => element.getAttribute('height'),
-      },
-      style: {
-        renderHTML: (attributes) => {
-          return attributes.style
-            ? {
-                style: attributes.style,
-              }
-            : {};
-        },
-        parseHTML: (element) => element.getAttribute('style'),
-      },
-    };
-  },
-
-  parseHTML() {
-    return [
-      {
-        tag: 'iframe',
-      },
-    ];
-  },
-
-  renderHTML({ HTMLAttributes }) {
-    return ['div', this.options.HTMLAttributes, ['iframe', HTMLAttributes]];
-  },
-
-  addCommands() {
-    return {
-      setIframe:
-        (options: { src: string }) =>
-        ({ tr, dispatch }) => {
-          const { selection } = tr;
-          const node = this.type.create(options);
-
-          if (dispatch) {
-            tr.replaceRangeWith(selection.from, selection.to, node);
-          }
-
-          return true;
-        },
-    };
-  },
-});

package/src/iframe/index.ts

@@ -1,5 +0,0 @@
-import { Iframe } from './iframe';
-
-export * from './iframe';
-
-export default Iframe;