@udecode/plate-basic-marks/dist/index.mjs

Basic marks plugin for Plate

// src/lib/BaseBasicMarksPlugin.ts
import { createSlatePlugin as createSlatePlugin8 } from "@udecode/plate";

// src/lib/BaseBoldPlugin.ts
import { createSlatePlugin, KEYS, someHtmlElement } from "@udecode/plate";
var BaseBoldPlugin = createSlatePlugin({
  key: KEYS.bold,
  node: { isLeaf: true },
  parsers: {
    html: {
      deserializer: {
        rules: [
          { validNodeName: ["STRONG", "B"] },
          {
            validStyle: {
              fontWeight: ["600", "700", "bold"]
            }
          }
        ],
        query: ({ element }) => !someHtmlElement(
          element,
          (node) => node.style.fontWeight === "normal"
        )
      }
    }
  },
  render: { as: "strong" }
}).extendTransforms(({ editor, type }) => ({
  toggle: () => {
    editor.tf.toggleMark(type);
  }
}));

// src/lib/BaseCodePlugin.ts
import { createSlatePlugin as createSlatePlugin2, findHtmlParentElement, KEYS as KEYS2 } from "@udecode/plate";
var BaseCodePlugin = createSlatePlugin2({
  key: KEYS2.code,
  node: { isLeaf: true },
  parsers: {
    html: {
      deserializer: {
        rules: [
          { validNodeName: ["CODE"] },
          { validStyle: { fontFamily: "Consolas" } }
        ],
        query({ element }) {
          const blockAbove = findHtmlParentElement(element, "P");
          if (blockAbove?.style.fontFamily === "Consolas") return false;
          return !findHtmlParentElement(element, "PRE");
        }
      }
    }
  },
  render: { as: "code" }
}).extendTransforms(({ editor, type }) => ({
  toggle: () => {
    editor.tf.toggleMark(type);
  }
}));

// src/lib/BaseItalicPlugin.ts
import { createSlatePlugin as createSlatePlugin3, KEYS as KEYS3, someHtmlElement as someHtmlElement2 } from "@udecode/plate";
var BaseItalicPlugin = createSlatePlugin3({
  key: KEYS3.italic,
  node: { isLeaf: true },
  parsers: {
    html: {
      deserializer: {
        rules: [
          { validNodeName: ["EM", "I"] },
          { validStyle: { fontStyle: "italic" } }
        ],
        query: ({ element }) => !someHtmlElement2(
          element,
          (node) => node.style.fontStyle === "normal"
        )
      }
    }
  },
  render: { as: "em" }
}).extendTransforms(({ editor, type }) => ({
  toggle: () => {
    editor.tf.toggleMark(type);
  }
}));

// src/lib/BaseStrikethroughPlugin.ts
import { createSlatePlugin as createSlatePlugin4, KEYS as KEYS4, someHtmlElement as someHtmlElement3 } from "@udecode/plate";
var BaseStrikethroughPlugin = createSlatePlugin4({
  key: KEYS4.strikethrough,
  node: { isLeaf: true },
  parsers: {
    html: {
      deserializer: {
        rules: [
          { validNodeName: ["S", "DEL", "STRIKE"] },
          { validStyle: { textDecoration: "line-through" } }
        ],
        query: ({ element }) => !someHtmlElement3(
          element,
          (node) => node.style.textDecoration === "none"
        )
      }
    }
  },
  render: { as: "s" }
}).extendTransforms(({ editor, type }) => ({
  toggle: () => {
    editor.tf.toggleMark(type);
  }
}));

// src/lib/BaseSubscriptPlugin.ts
import { createSlatePlugin as createSlatePlugin5, KEYS as KEYS5 } from "@udecode/plate";
var BaseSubscriptPlugin = createSlatePlugin5({
  key: KEYS5.sub,
  node: { isLeaf: true },
  parsers: {
    html: {
      deserializer: {
        rules: [
          { validNodeName: ["SUB"] },
          { validStyle: { verticalAlign: "sub" } }
        ]
      }
    }
  },
  render: { as: "sub" }
}).extendTransforms(({ editor, type }) => ({
  toggle: () => {
    editor.tf.toggleMark(type, {
      remove: editor.getType(KEYS5.sup)
    });
  }
}));

// src/lib/BaseSuperscriptPlugin.ts
import { createSlatePlugin as createSlatePlugin6, KEYS as KEYS6 } from "@udecode/plate";
var BaseSuperscriptPlugin = createSlatePlugin6({
  key: KEYS6.sup,
  node: { isLeaf: true },
  parsers: {
    html: {
      deserializer: {
        rules: [
          { validNodeName: ["SUP"] },
          { validStyle: { verticalAlign: "super" } }
        ]
      }
    }
  },
  render: { as: "sup" }
}).extendTransforms(({ editor, type }) => ({
  toggle: () => {
    editor.tf.toggleMark(type, {
      remove: editor.getType(KEYS6.sub)
    });
  }
}));

// src/lib/BaseUnderlinePlugin.ts
import { createSlatePlugin as createSlatePlugin7, KEYS as KEYS7, someHtmlElement as someHtmlElement4 } from "@udecode/plate";
var BaseUnderlinePlugin = createSlatePlugin7({
  key: KEYS7.underline,
  node: { isLeaf: true },
  parsers: {
    html: {
      deserializer: {
        rules: [
          { validNodeName: ["U"] },
          { validStyle: { textDecoration: ["underline"] } }
        ],
        query: ({ element }) => !someHtmlElement4(
          element,
          (node) => node.style.textDecoration === "none"
        )
      }
    }
  },
  render: { as: "u" }
}).extendTransforms(({ editor, type }) => ({
  toggle: () => {
    editor.tf.toggleMark(type);
  }
}));

// src/lib/BaseBasicMarksPlugin.ts
var BaseBasicMarksPlugin = createSlatePlugin8({
  plugins: [
    BaseBoldPlugin,
    BaseCodePlugin,
    BaseItalicPlugin,
    BaseStrikethroughPlugin,
    BaseSubscriptPlugin,
    BaseSuperscriptPlugin,
    BaseUnderlinePlugin
  ]
});

// src/lib/BaseHighlightPlugin.ts
import { createSlatePlugin as createSlatePlugin9, KEYS as KEYS8 } from "@udecode/plate";
var BaseHighlightPlugin = createSlatePlugin9({
  key: KEYS8.highlight,
  node: { isLeaf: true },
  parsers: {
    html: {
      deserializer: {
        rules: [
          {
            validNodeName: ["MARK"]
          }
        ]
      }
    }
  },
  render: { as: "mark" }
}).extendTransforms(({ editor, type }) => ({
  toggle: () => {
    editor.tf.toggleMark(type);
  }
}));

// src/lib/BaseKbdPlugin.ts
import { createSlatePlugin as createSlatePlugin10, KEYS as KEYS9 } from "@udecode/plate";
var BaseKbdPlugin = createSlatePlugin10({
  key: KEYS9.kbd,
  node: { isLeaf: true },
  parsers: {
    html: {
      deserializer: {
        rules: [{ validNodeName: ["KBD"] }]
      }
    }
  },
  render: { as: "kbd" }
}).extendTransforms(({ editor, type }) => ({
  toggle: () => {
    editor.tf.toggleMark(type);
  }
}));
export {
  BaseBasicMarksPlugin,
  BaseBoldPlugin,
  BaseCodePlugin,
  BaseHighlightPlugin,
  BaseItalicPlugin,
  BaseKbdPlugin,
  BaseStrikethroughPlugin,
  BaseSubscriptPlugin,
  BaseSuperscriptPlugin,
  BaseUnderlinePlugin
};
//# sourceMappingURL=index.mjs.map