@udecode/plate-basic-marks/dist/react/index.js

Basic marks plugin for Plate

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/react/index.ts
var react_exports = {};
__export(react_exports, {
  BasicMarksPlugin: () => BasicMarksPlugin,
  BoldPlugin: () => BoldPlugin,
  CodePlugin: () => CodePlugin,
  HighlightPlugin: () => HighlightPlugin,
  ItalicPlugin: () => ItalicPlugin,
  KbdPlugin: () => KbdPlugin,
  StrikethroughPlugin: () => StrikethroughPlugin,
  SubscriptPlugin: () => SubscriptPlugin,
  SuperscriptPlugin: () => SuperscriptPlugin,
  UnderlinePlugin: () => UnderlinePlugin
});
module.exports = __toCommonJS(react_exports);

// src/react/BasicMarksPlugin.tsx
var import_react8 = require("@udecode/plate/react");

// src/lib/BaseBasicMarksPlugin.ts
var import_plate8 = require("@udecode/plate");

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

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

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

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

// src/lib/BaseSubscriptPlugin.ts
var import_plate5 = require("@udecode/plate");
var BaseSubscriptPlugin = (0, import_plate5.createSlatePlugin)({
  key: import_plate5.KEYS.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(import_plate5.KEYS.sup)
    });
  }
}));

// src/lib/BaseSuperscriptPlugin.ts
var import_plate6 = require("@udecode/plate");
var BaseSuperscriptPlugin = (0, import_plate6.createSlatePlugin)({
  key: import_plate6.KEYS.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(import_plate6.KEYS.sub)
    });
  }
}));

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

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

// src/react/BoldPlugin.tsx
var import_react = require("@udecode/plate/react");
var BoldPlugin = (0, import_react.toPlatePlugin)(BaseBoldPlugin, {
  shortcuts: { toggle: { keys: [[import_react.Key.Mod, "b"]] } }
});

// src/react/CodePlugin.tsx
var import_react2 = require("@udecode/plate/react");
var CodePlugin = (0, import_react2.toPlatePlugin)(BaseCodePlugin);

// src/react/ItalicPlugin.tsx
var import_react3 = require("@udecode/plate/react");
var ItalicPlugin = (0, import_react3.toPlatePlugin)(BaseItalicPlugin, {
  shortcuts: { toggle: { keys: [[import_react3.Key.Mod, "i"]] } }
});

// src/react/StrikethroughPlugin.tsx
var import_react4 = require("@udecode/plate/react");
var StrikethroughPlugin = (0, import_react4.toPlatePlugin)(BaseStrikethroughPlugin);

// src/react/SubscriptPlugin.tsx
var import_react5 = require("@udecode/plate/react");
var SubscriptPlugin = (0, import_react5.toPlatePlugin)(BaseSubscriptPlugin);

// src/react/SuperscriptPlugin.tsx
var import_react6 = require("@udecode/plate/react");
var SuperscriptPlugin = (0, import_react6.toPlatePlugin)(BaseSuperscriptPlugin);

// src/react/UnderlinePlugin.tsx
var import_react7 = require("@udecode/plate/react");
var UnderlinePlugin = (0, import_react7.toPlatePlugin)(BaseUnderlinePlugin, {
  shortcuts: { toggle: { keys: [[import_react7.Key.Mod, "u"]] } }
});

// src/react/BasicMarksPlugin.tsx
var BasicMarksPlugin = (0, import_react8.toPlatePlugin)(BaseBasicMarksPlugin, {
  plugins: [
    BoldPlugin,
    CodePlugin,
    ItalicPlugin,
    StrikethroughPlugin,
    SubscriptPlugin,
    SuperscriptPlugin,
    UnderlinePlugin
  ]
});

// src/react/HighlightPlugin.tsx
var import_react9 = require("@udecode/plate/react");

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

// src/react/HighlightPlugin.tsx
var HighlightPlugin = (0, import_react9.toPlatePlugin)(BaseHighlightPlugin);

// src/react/KbdPlugin.tsx
var import_react10 = require("@udecode/plate/react");

// src/lib/BaseKbdPlugin.ts
var import_plate10 = require("@udecode/plate");
var BaseKbdPlugin = (0, import_plate10.createSlatePlugin)({
  key: import_plate10.KEYS.kbd,
  node: { isLeaf: true },
  parsers: {
    html: {
      deserializer: {
        rules: [{ validNodeName: ["KBD"] }]
      }
    }
  },
  render: { as: "kbd" }
}).extendTransforms(({ editor, type }) => ({
  toggle: () => {
    editor.tf.toggleMark(type);
  }
}));

// src/react/KbdPlugin.tsx
var KbdPlugin = (0, import_react10.toPlatePlugin)(BaseKbdPlugin);
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  BasicMarksPlugin,
  BoldPlugin,
  CodePlugin,
  HighlightPlugin,
  ItalicPlugin,
  KbdPlugin,
  StrikethroughPlugin,
  SubscriptPlugin,
  SuperscriptPlugin,
  UnderlinePlugin
});
//# sourceMappingURL=index.js.map