@collabchron/notiq 0.2.0 → 1.0.0

package/{src/components/editor/nodes/Stepper/index.tsx → dist/chunk-6RNZQOH2.mjs}

@@ -1,260 +1,214 @@
-import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
-import {
-  SerializedLexicalNode,
-  SerializedEditor,
-  Spread,
-  DecoratorNode,
-  NodeKey,
-  LexicalNode,
-  createEditor,
-  LexicalCommand,
-  createCommand,
-  $getSelection,
-  $isRangeSelection,
-  COMMAND_PRIORITY_LOW,
-  LexicalEditor,
-  EditorState,
-} from "lexical";
-import React, { Suspense, useEffect } from "react";
-const StepperComponent = React.lazy(
-  () => import("@/components/ui/stepper/stepper")
-);
-
-export interface StepType {
-  title: string;
-  id: number;
-  content: LexicalEditor;
-}
-
-export type StepsType = StepType[];
-
-export type SerializedStepper = Spread<
-  {
-    type: "stepper";
-    steps: {
-      title: string;
-      id: string;
-      content: SerializedEditor;
-    }[];
-  },
-  SerializedLexicalNode
->;
-
-export const initialEditorState = {
-  root: {
-    children: [
-      {
-        children: [
-          {
-            detail: 0,
-            format: 0,
-            mode: "normal",
-            style: "",
-            text: "type the content here..",
-            type: "text",
-            version: 1,
-          },
-        ],
-        direction: null,
-        format: "",
-        indent: 0,
-        type: "paragraph",
-        version: 1,
-        textFormat: 0,
-        textStyle: "",
-      },
-    ],
-    direction: null,
-    format: "",
-    indent: 0,
-    type: "root",
-    version: 1,
-  },
-};
-
-export class StepperNode extends DecoratorNode<React.ReactElement> {
-  __steps: StepsType;
-
-  constructor(steps: StepsType, key?: NodeKey) {
-    super(key);
-    this.__steps = steps.map((step) => {
-      if (!step.content) {
-        const newEditor = createEditor();
-        const parsedEditorState = newEditor.parseEditorState(
-          JSON.stringify(initialEditorState)
-        );
-        newEditor.setEditorState(parsedEditorState);
-        return { ...step, content: newEditor };
-      }
-      return step;
-    });
-  }
-
-  static getType(): string {
-    return "stepper";
-  }
-
-  addStep(step: Omit<StepType, "content">) {
-    const self = this.getWritable();
-    const newEditor = createEditor();
-    const parsedEditorState = newEditor.parseEditorState(
-      JSON.stringify(initialEditorState)
-    );
-    newEditor.setEditorState(parsedEditorState);
-    const newStep: StepType = {
-      ...step,
-      content: newEditor,
-    };
-    self.__steps.push(newStep);
-    return self;
-  }
-
-  insertStepAtIndex(step: Omit<StepType, "content">, index: number) {
-    if (index < 0 || index > this.__steps.length) {
-      throw new Error("Invalid index for inserting step.");
-    }
-    const self = this.getWritable();
-    const newEditor = createEditor();
-    const parsedEditorState = newEditor.parseEditorState(
-      JSON.stringify(initialEditorState)
-    );
-    newEditor.setEditorState(parsedEditorState);
-    const newStep: StepType = {
-      ...step,
-      content: newEditor,
-    };
-    self.__steps.splice(index, 0, newStep);
-    return self;
-  }
-  deleteStep(id: number) {
-    const self = this.getWritable();
-    self.__steps = self.__steps.filter(step => step.id !== id);
-    return self;
-  }
-  updateTitle(id: number, title: string) {
-    const self = this.getWritable();
-    const step = self.__steps.find(s => s.id === id);
-    if (step) step.title = title;
-    return self;
-  }
-  
-  
-  replaceSteps(steps: StepsType) {
-    const self = this.getWritable();
-    self.__steps = steps.map((step) => {
-      if (step.content) return step;
-      const newEditor = createEditor();
-      const parsedEditorState = newEditor.parseEditorState(
-        JSON.stringify(initialEditorState)
-      );
-      newEditor.setEditorState(parsedEditorState);
-      return { ...step, content: newEditor };
-    });
-    return self;
-  }
-
-  reorderSteps(newSteps: StepsType) {
-    const self = this.getWritable();
-    self.__steps = newSteps;
-    return self;
-  }
-
-
-  static clone(node: StepperNode): StepperNode {
-    return new StepperNode(node.__steps, node.__key);
-  }
-
-  static importJSON(serializedNode: SerializedStepper): StepperNode {
-    const steps: StepType[] = serializedNode.steps.map((serializedStep) => {
-      const newEditor = createEditor();
-      const editorState = newEditor.parseEditorState(
-        serializedStep.content.editorState
-      );
-      newEditor.setEditorState(editorState);
-      return {
-        title: serializedStep.title,
-        id: parseInt(serializedStep.id, 10),
-        content: newEditor,
-      };
-    });
-    return new StepperNode(steps);
-  }
-
-  exportJSON(): SerializedStepper {
-    return {
-      ...super.exportJSON(),
-      steps: this.__steps.map((step) => ({
-        title: step.title,
-        id: step.id.toString(),
-        content: {
-          editorState: step.content.getEditorState().toJSON(),
-        },
-      })),
-      type: "stepper",
-    };
-  }
-
-  createDOM(): HTMLElement {
-    const element = document.createElement("div");
-    element.className = `stepper-${this.__type}`;
-    return element;
-  }
-
-  updateDOM(): false {
-    return false;
-  }
-
-  decorate(): React.ReactElement {
-    return (
-      <Suspense fallback={null}>
-        <div>
-          <StepperComponent steps={this.__steps} nodeKey={this.getKey()} />
-        </div>
-      </Suspense>
-    );
-  }
-}
-
-export function $isStepperNode(
-  node: LexicalNode | null | undefined
-): node is StepperNode {
-  return node instanceof StepperNode;
-}
-
-export function $createStepperNode(steps: StepsType): StepperNode {
-  return new StepperNode(steps);
-}
-
-export const INSERT_STEPPER_COMMAND: LexicalCommand<StepsType> =
-  createCommand();
-
-export function $insertStepperNode(steps: StepsType) {
-  const selection = $getSelection();
-  if ($isRangeSelection(selection)) {
-    const stepperNode = $createStepperNode(steps);
-    selection.insertNodes([stepperNode]);
-  }
-}
-
-export default function StepperPlugin() {
-  const [editor] = useLexicalComposerContext();
-  useEffect(() => {
-    if (!editor.hasNodes([StepperNode])) {
-      throw new Error("StepperNode: StepperNode not registered on editor");
-    }
-  }, [editor]);
-  useEffect(() => {
-    return editor.registerCommand(
-      INSERT_STEPPER_COMMAND,
-      (payload: StepsType) => {
-        editor.update(() => {
-          $insertStepperNode(payload);
-        });
-        return true;
-      },
-      COMMAND_PRIORITY_LOW
-    );
-  }, [editor]);
-
-  return null;
-}
+import {
+  __spreadProps,
+  __spreadValues,
+  init_react_shim
+} from "./chunk-77KXU36M.mjs";
+
+// src/components/editor/nodes/Stepper/index.tsx
+init_react_shim();
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import {
+  DecoratorNode,
+  createEditor,
+  createCommand,
+  $getSelection,
+  $isRangeSelection,
+  COMMAND_PRIORITY_LOW
+} from "lexical";
+import React, { Suspense, useEffect } from "react";
+var StepperComponent = React.lazy(
+  () => import("./stepper-FSARL6X6.mjs")
+);
+var initialEditorState = {
+  root: {
+    children: [
+      {
+        children: [
+          {
+            detail: 0,
+            format: 0,
+            mode: "normal",
+            style: "",
+            text: "type the content here..",
+            type: "text",
+            version: 1
+          }
+        ],
+        direction: null,
+        format: "",
+        indent: 0,
+        type: "paragraph",
+        version: 1,
+        textFormat: 0,
+        textStyle: ""
+      }
+    ],
+    direction: null,
+    format: "",
+    indent: 0,
+    type: "root",
+    version: 1
+  }
+};
+var StepperNode = class _StepperNode extends DecoratorNode {
+  constructor(steps, key) {
+    super(key);
+    this.__steps = steps.map((step) => {
+      if (!step.content) {
+        const newEditor = createEditor();
+        const parsedEditorState = newEditor.parseEditorState(
+          JSON.stringify(initialEditorState)
+        );
+        newEditor.setEditorState(parsedEditorState);
+        return __spreadProps(__spreadValues({}, step), { content: newEditor });
+      }
+      return step;
+    });
+  }
+  static getType() {
+    return "stepper";
+  }
+  addStep(step) {
+    const self = this.getWritable();
+    const newEditor = createEditor();
+    const parsedEditorState = newEditor.parseEditorState(
+      JSON.stringify(initialEditorState)
+    );
+    newEditor.setEditorState(parsedEditorState);
+    const newStep = __spreadProps(__spreadValues({}, step), {
+      content: newEditor
+    });
+    self.__steps.push(newStep);
+    return self;
+  }
+  insertStepAtIndex(step, index) {
+    if (index < 0 || index > this.__steps.length) {
+      throw new Error("Invalid index for inserting step.");
+    }
+    const self = this.getWritable();
+    const newEditor = createEditor();
+    const parsedEditorState = newEditor.parseEditorState(
+      JSON.stringify(initialEditorState)
+    );
+    newEditor.setEditorState(parsedEditorState);
+    const newStep = __spreadProps(__spreadValues({}, step), {
+      content: newEditor
+    });
+    self.__steps.splice(index, 0, newStep);
+    return self;
+  }
+  deleteStep(id) {
+    const self = this.getWritable();
+    self.__steps = self.__steps.filter((step) => step.id !== id);
+    return self;
+  }
+  updateTitle(id, title) {
+    const self = this.getWritable();
+    const step = self.__steps.find((s) => s.id === id);
+    if (step) step.title = title;
+    return self;
+  }
+  replaceSteps(steps) {
+    const self = this.getWritable();
+    self.__steps = steps.map((step) => {
+      if (step.content) return step;
+      const newEditor = createEditor();
+      const parsedEditorState = newEditor.parseEditorState(
+        JSON.stringify(initialEditorState)
+      );
+      newEditor.setEditorState(parsedEditorState);
+      return __spreadProps(__spreadValues({}, step), { content: newEditor });
+    });
+    return self;
+  }
+  reorderSteps(newSteps) {
+    const self = this.getWritable();
+    self.__steps = newSteps;
+    return self;
+  }
+  static clone(node) {
+    return new _StepperNode(node.__steps, node.__key);
+  }
+  static importJSON(serializedNode) {
+    const steps = serializedNode.steps.map((serializedStep) => {
+      const newEditor = createEditor();
+      const editorState = newEditor.parseEditorState(
+        serializedStep.content.editorState
+      );
+      newEditor.setEditorState(editorState);
+      return {
+        title: serializedStep.title,
+        id: parseInt(serializedStep.id, 10),
+        content: newEditor
+      };
+    });
+    return new _StepperNode(steps);
+  }
+  exportJSON() {
+    return __spreadProps(__spreadValues({}, super.exportJSON()), {
+      steps: this.__steps.map((step) => ({
+        title: step.title,
+        id: step.id.toString(),
+        content: {
+          editorState: step.content.getEditorState().toJSON()
+        }
+      })),
+      type: "stepper"
+    });
+  }
+  createDOM() {
+    const element = document.createElement("div");
+    element.className = `stepper-${this.__type}`;
+    return element;
+  }
+  updateDOM() {
+    return false;
+  }
+  decorate() {
+    return /* @__PURE__ */ React.createElement(Suspense, { fallback: null }, /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(StepperComponent, { steps: this.__steps, nodeKey: this.getKey() })));
+  }
+};
+function $isStepperNode(node) {
+  return node instanceof StepperNode;
+}
+function $createStepperNode(steps) {
+  return new StepperNode(steps);
+}
+var INSERT_STEPPER_COMMAND = createCommand();
+function $insertStepperNode(steps) {
+  const selection = $getSelection();
+  if ($isRangeSelection(selection)) {
+    const stepperNode = $createStepperNode(steps);
+    selection.insertNodes([stepperNode]);
+  }
+}
+function StepperPlugin() {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    if (!editor.hasNodes([StepperNode])) {
+      throw new Error("StepperNode: StepperNode not registered on editor");
+    }
+  }, [editor]);
+  useEffect(() => {
+    return editor.registerCommand(
+      INSERT_STEPPER_COMMAND,
+      (payload) => {
+        editor.update(() => {
+          $insertStepperNode(payload);
+        });
+        return true;
+      },
+      COMMAND_PRIORITY_LOW
+    );
+  }, [editor]);
+  return null;
+}
+
+export {
+  initialEditorState,
+  StepperNode,
+  $isStepperNode,
+  $createStepperNode,
+  INSERT_STEPPER_COMMAND,
+  StepperPlugin
+};

package/dist/chunk-77KXU36M.mjs

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// react-shim.js
+import * as React from "react";
+var init_react_shim = __esm({
+  "react-shim.js"() {
+    "use strict";
+    if (typeof globalThis !== "undefined") {
+      globalThis.React = React;
+    } else if (typeof window !== "undefined") {
+      window.React = React;
+    } else if (typeof global !== "undefined") {
+      global.React = React;
+    }
+  }
+});
+
+export {
+  __spreadValues,
+  __spreadProps,
+  __objRest,
+  __commonJS,
+  __publicField,
+  React,
+  init_react_shim
+};