@collabchron/notiq 0.2.0 → 1.0.0

package/dist/chunk-BIU7WTLX.mjs

@@ -0,0 +1,95 @@
+import {
+  cn
+} from "./chunk-YHPNOWFH.mjs";
+import {
+  __objRest,
+  __spreadValues,
+  init_react_shim
+} from "./chunk-77KXU36M.mjs";
+
+// src/components/ui/button.tsx
+init_react_shim();
+import * as React2 from "react";
+import { Slot } from "@radix-ui/react-slot";
+import { cva } from "class-variance-authority";
+
+// src/components/ui/tooltip.tsx
+init_react_shim();
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+var TooltipProvider = TooltipPrimitive.Provider;
+var Tooltip = TooltipPrimitive.Root;
+var TooltipTrigger = TooltipPrimitive.Trigger;
+var TooltipContent = React.forwardRef((_a, ref) => {
+  var _b = _a, { className, sideOffset = 4 } = _b, props = __objRest(_b, ["className", "sideOffset"]);
+  return /* @__PURE__ */ React.createElement(TooltipPrimitive.Portal, null, /* @__PURE__ */ React.createElement(
+    TooltipPrimitive.Content,
+    __spreadValues({
+      ref,
+      sideOffset,
+      className: cn(
+        "z-50 overflow-hidden rounded-md bg-primary px-3 py-1.5 text-xs text-primary-foreground animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
+        className
+      )
+    }, props)
+  ));
+});
+TooltipContent.displayName = TooltipPrimitive.Content.displayName;
+
+// src/components/ui/button.tsx
+var buttonVariants = cva(
+  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground shadow hover:bg-primary/90",
+        destructive: "bg-destructive text-destructive-foreground shadow-sm hover:bg-destructive/90",
+        outline: "border border-input bg-background shadow-sm hover:bg-accent hover:text-accent-foreground",
+        secondary: "bg-secondary text-secondary-foreground shadow-sm hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground",
+        link: "text-primary underline-offset-4 hover:underline",
+        transparent: "bg-transparent border border-input"
+      },
+      size: {
+        default: "h-9 px-4 py-2",
+        sm: "h-8 rounded-md px-3 text-xs",
+        lg: "h-10 rounded-md px-8",
+        icon: "h-9 w-9",
+        Toolbar: "h-7 w-7 p-3 ",
+        custom: ""
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+);
+var Button = React2.forwardRef(
+  (_a, ref) => {
+    var _b = _a, { className, variant, tip, size, asChild = false } = _b, props = __objRest(_b, ["className", "variant", "tip", "size", "asChild"]);
+    const Comp = asChild ? Slot : "button";
+    return /* @__PURE__ */ React2.createElement(React2.Fragment, null, !!tip ? /* @__PURE__ */ React2.createElement(TooltipProvider, null, /* @__PURE__ */ React2.createElement(Tooltip, null, /* @__PURE__ */ React2.createElement(TooltipTrigger, { asChild: true }, /* @__PURE__ */ React2.createElement(
+      Comp,
+      __spreadValues({
+        className: cn(buttonVariants({ variant, size, className })),
+        ref
+      }, props)
+    )), /* @__PURE__ */ React2.createElement(TooltipContent, null, /* @__PURE__ */ React2.createElement("p", null, tip)))) : /* @__PURE__ */ React2.createElement(
+      Comp,
+      __spreadValues({
+        className: cn(buttonVariants({ variant, size, className })),
+        ref
+      }, props)
+    ));
+  }
+);
+Button.displayName = "Button";
+
+export {
+  TooltipProvider,
+  Tooltip,
+  TooltipTrigger,
+  TooltipContent,
+  Button
+};

package/dist/chunk-EGMI62PP.mjs

@@ -0,0 +1,83 @@
+import {
+  Command,
+  CommandEmpty,
+  CommandGroup,
+  CommandInput,
+  CommandItem,
+  CommandList,
+  CommandShortcut
+} from "./chunk-KJ6AJ44Q.mjs";
+import {
+  Popover,
+  PopoverContent,
+  PopoverTrigger
+} from "./chunk-64Z3FI7T.mjs";
+import {
+  Button
+} from "./chunk-BIU7WTLX.mjs";
+import {
+  cn
+} from "./chunk-YHPNOWFH.mjs";
+import {
+  init_react_shim
+} from "./chunk-77KXU36M.mjs";
+
+// src/components/ui/drop-downs/index.tsx
+init_react_shim();
+import * as React from "react";
+import { ChevronsUpDown } from "lucide-react";
+function DropDown({
+  className,
+  TriggerLabel,
+  TriggerClassName,
+  values,
+  disabled,
+  PopoverContentClassName,
+  triggerVariants = "outline",
+  ShowChevronsUpDown = true,
+  side = "bottom",
+  sideOffset = 5
+}) {
+  const [value, setValue] = React.useState("");
+  return /* @__PURE__ */ React.createElement(Popover, { modal: false }, /* @__PURE__ */ React.createElement(PopoverTrigger, { disabled, asChild: true }, /* @__PURE__ */ React.createElement(
+    Button,
+    {
+      variant: triggerVariants,
+      role: "combobox",
+      size: "Toolbar",
+      style: TriggerClassName,
+      className
+    },
+    /* @__PURE__ */ React.createElement("div", { className: "flex  flex-row justify-center gap-x-3 items-center" }, TriggerLabel),
+    ShowChevronsUpDown && /* @__PURE__ */ React.createElement(ChevronsUpDown, { className: "ml-2 h-4 w-4 shrink-0 opacity-50" })
+  )), /* @__PURE__ */ React.createElement(
+    PopoverContent,
+    {
+      side,
+      sideOffset,
+      style: PopoverContentClassName,
+      className: "w-[200px] p-0 dropdown-portal"
+    },
+    /* @__PURE__ */ React.createElement(Command, null, /* @__PURE__ */ React.createElement(CommandInput, { placeholder: "Search..." }), /* @__PURE__ */ React.createElement(CommandList, null, /* @__PURE__ */ React.createElement(CommandEmpty, null, "No found."), /* @__PURE__ */ React.createElement(CommandGroup, null, values.map((framework) => /* @__PURE__ */ React.createElement(
+      CommandItem,
+      {
+        key: framework.label,
+        value: framework.label,
+        style: framework.style,
+        className: cn(
+          "cursor-pointer",
+          value === framework.label && "bg-gray-300/10"
+        ),
+        onSelect: (currentValue) => {
+          setValue(currentValue === value ? "" : currentValue);
+          if (framework.func) framework == null ? void 0 : framework.func();
+        }
+      },
+      /* @__PURE__ */ React.createElement("div", { className: "flex w-full flex-row items-center justify-between" }, /* @__PURE__ */ React.createElement("div", { className: "flex  items-center gap-4 flex-row" }, framework.icon, /* @__PURE__ */ React.createElement("div", { className: "flex flex-col" }, framework.label, /* @__PURE__ */ React.createElement("span", { className: "text-sm text-muted-foreground" }, framework.desc))), framework.shortcuts && /* @__PURE__ */ React.createElement(CommandShortcut, null, framework.shortcuts))
+    )))))
+  ));
+}
+
+export {
+  DropDown
+};

package/dist/chunk-EHNQD5KO.mjs

@@ -0,0 +1,88 @@
+import {
+  ExcalidrawModal
+} from "./chunk-XWC4TK2N.mjs";
+import {
+  $createExcalidrawNode,
+  ExcalidrawNode
+} from "./chunk-KJV3FAZ7.mjs";
+import {
+  React,
+  init_react_shim
+} from "./chunk-77KXU36M.mjs";
+
+// src/components/editor/plugins/ExcalidrawPlugin/index.tsx
+init_react_shim();
+import "@excalidraw/excalidraw/index.css";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { $wrapNodeInElement } from "@lexical/utils";
+import {
+  $createParagraphNode,
+  $insertNodes,
+  $isRootOrShadowRoot,
+  COMMAND_PRIORITY_EDITOR,
+  createCommand
+} from "lexical";
+import { useEffect, useState } from "react";
+var INSERT_EXCALIDRAW_COMMAND = createCommand(
+  "INSERT_EXCALIDRAW_COMMAND"
+);
+function ExcalidrawPlugin() {
+  const [editor] = useLexicalComposerContext();
+  const [isModalOpen, setModalOpen] = useState(false);
+  useEffect(() => {
+    if (!editor.hasNodes([ExcalidrawNode])) {
+      throw new Error(
+        "ExcalidrawPlugin: ExcalidrawNode not registered on editor"
+      );
+    }
+    return editor.registerCommand(
+      INSERT_EXCALIDRAW_COMMAND,
+      () => {
+        setModalOpen(true);
+        return true;
+      },
+      COMMAND_PRIORITY_EDITOR
+    );
+  }, [editor]);
+  const onClose = () => {
+    setModalOpen(false);
+  };
+  const onDelete = () => {
+    setModalOpen(false);
+  };
+  const onSave = (elements, appState, files) => {
+    editor.update(() => {
+      const excalidrawNode = $createExcalidrawNode();
+      excalidrawNode.setData(
+        JSON.stringify({
+          appState,
+          elements,
+          files
+        })
+      );
+      $insertNodes([excalidrawNode]);
+      if ($isRootOrShadowRoot(excalidrawNode.getParentOrThrow())) {
+        $wrapNodeInElement(excalidrawNode, $createParagraphNode).selectEnd();
+      }
+    });
+    setModalOpen(false);
+  };
+  return isModalOpen ? /* @__PURE__ */ React.createElement(
+    ExcalidrawModal,
+    {
+      initialElements: [],
+      initialAppState: {},
+      initialFiles: {},
+      isShown: isModalOpen,
+      onDelete,
+      onClose,
+      onSave,
+      closeOnClickOutside: false
+    }
+  ) : null;
+}
+
+export {
+  INSERT_EXCALIDRAW_COMMAND,
+  ExcalidrawPlugin
+};

package/dist/chunk-FSM26655.mjs

@@ -0,0 +1,37 @@
+import {
+  cn
+} from "./chunk-YHPNOWFH.mjs";
+import {
+  __objRest,
+  __spreadValues,
+  init_react_shim
+} from "./chunk-77KXU36M.mjs";
+
+// src/components/ui/badge.tsx
+init_react_shim();
+import * as React from "react";
+import { cva } from "class-variance-authority";
+var badgeVariants = cva(
+  "inline-flex items-center rounded-md border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
+  {
+    variants: {
+      variant: {
+        default: "border-transparent bg-primary text-primary-foreground shadow hover:bg-primary/80",
+        secondary: "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        destructive: "border-transparent bg-destructive text-destructive-foreground shadow hover:bg-destructive/80",
+        outline: "text-foreground"
+      }
+    },
+    defaultVariants: {
+      variant: "default"
+    }
+  }
+);
+function Badge(_a) {
+  var _b = _a, { className, variant } = _b, props = __objRest(_b, ["className", "variant"]);
+  return /* @__PURE__ */ React.createElement("div", __spreadValues({ className: cn(badgeVariants({ variant }), className) }, props));
+}
+
+export {
+  Badge
+};

package/{src/components/editor/nodes/Hint/index.tsx → dist/chunk-G53GLEAY.mjs}

@@ -1,190 +1,158 @@
-import {
-    createCommand,
-    createEditor,
-    DecoratorNode,
-    LexicalCommand,
-    LexicalEditor,
-    LexicalNode,
-    NodeKey,
-    SerializedEditor,
-    SerializedLexicalNode,
-    Spread,
-    $getSelection,
-    $isRangeSelection,
-    COMMAND_PRIORITY_LOW,
-} from "lexical";
-import React, { Suspense, useEffect } from "react";
-import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
-const HintComponent = React.lazy(() => import("./HintComponet"));
-
-export type HintType = "success" | "warning" | "info" | "error" | "hint";
-
-
-export type SerializedHint = Spread<
-  {
-    type: "hint"; 
-    variant: HintType;
-    caption: SerializedEditor;
-  },
-  SerializedLexicalNode
->;
-
-export class Hint extends DecoratorNode<React.ReactElement> {
-  __variant: HintType;
-  __caption: LexicalEditor;
-
-  constructor(variant: HintType, caption?: LexicalEditor, key?: NodeKey) {
-    super(key);
-    this.__variant = variant;
-    if (!caption) {
-      const initialEditorState = {
-        root: {
-          children: [
-            {
-              children: [
-                {
-                  detail: 0,
-                  format: 0,
-                  mode: "normal",
-                  style: "",
-                  text: " ",
-                  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,
-        },
-      };
-
-      const newEditor = createEditor();
-      const parsedEditorState = newEditor.parseEditorState(JSON.stringify(initialEditorState));
-      newEditor.setEditorState(parsedEditorState);
-
-      this.__caption = newEditor;
-    } else {
-      this.__caption = caption;
-    }
-  }
-
-  static getType(): string {
-    return "hint";
-  }
-
-  static clone(node: Hint): Hint {
-    return new Hint(node.__variant, node.__caption, node.__key);
-  }
-  static importJSON(serializedNode: SerializedHint): Hint {
-    return new Hint(
-      serializedNode.variant, // Change from type to variant
-      undefined
-    ).updateFromJSON(serializedNode);
-  }
-
-
-  setVariant(variant: HintType) {
-    const self = this.getWritable(); // Get mutable instance
-    self.__variant = variant;
-    return self;
-  }
-
-  createDOM(): HTMLElement {
-    const element = document.createElement("div");
-    element.className = `hint-${this.__type}`;
-    return element;
-  }
-
-  updateFromJSON(serializedNode: SerializedHint): this {
-    super.updateFromJSON(serializedNode);
-    const nestedEditor = this.__caption;
-    const editorState = nestedEditor.parseEditorState(serializedNode.caption.editorState);
-    if (!editorState.isEmpty()) {
-      nestedEditor.setEditorState(editorState);
-    }
-    return this;
-  }
-
-  exportJSON(): SerializedHint {
-    return {
-      ...super.exportJSON(),
-      variant: this.__variant,
-      type: "hint", 
-      caption: this.__caption.toJSON(),
-    };
-  }
-
-  updateDOM(): false {
-    return false;
-  }
-
-  decorate(): React.ReactElement {
-    return (
-      <Suspense fallback={null}>
-        <HintComponent
-          type={this.__variant}
-          captionEditor={this.__caption}
-          nodeKey={this.getKey()}
-        />
-      </Suspense>
-    );
-  }
-}
-
-export function $isHintNode(
-  node: LexicalNode | null | undefined
-): node is Hint {
-  return node instanceof Hint;
-}
-
-export function $createHintNode(
-  type: HintType,
-): Hint {
-  return new Hint(type);
-}
-
-export const INSERT_HINT_COMMAND: LexicalCommand<HintType> = createCommand();
-
-export function $insertHintNode(type: HintType) {
-  const selection = $getSelection();
-  if ($isRangeSelection(selection)) {
-    const hintNode = $createHintNode(type);
-    selection.insertNodes([hintNode]);
-  }
-}
-
-
-
-export default function HintPlugin() {
-  const [editor] = useLexicalComposerContext();
-  useEffect(() => {
-    if (!editor.hasNodes([Hint])) {
-      throw new Error("Hint: Hint not registered on editor");
-    }
-  }, [editor]);
-  useEffect(() => {
-    return editor.registerCommand(
-      INSERT_HINT_COMMAND,
-      (payload: HintType, editor: LexicalEditor) => {
-        editor.update(() => {
-          $insertHintNode(payload);
-        });
-        return true;
-      },
-      COMMAND_PRIORITY_LOW
-    );
-  }, [editor]);
-
-  return null;
-}
+import {
+  __spreadProps,
+  __spreadValues,
+  init_react_shim
+} from "./chunk-77KXU36M.mjs";
+
+// src/components/editor/nodes/Hint/index.tsx
+init_react_shim();
+import {
+  createCommand,
+  createEditor,
+  DecoratorNode,
+  $getSelection,
+  $isRangeSelection,
+  COMMAND_PRIORITY_LOW
+} from "lexical";
+import React, { Suspense, useEffect } from "react";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+var HintComponent = React.lazy(() => import("./HintComponet-BRL6EAMS.mjs"));
+var Hint = class _Hint extends DecoratorNode {
+  constructor(variant, caption, key) {
+    super(key);
+    this.__variant = variant;
+    if (!caption) {
+      const initialEditorState = {
+        root: {
+          children: [
+            {
+              children: [
+                {
+                  detail: 0,
+                  format: 0,
+                  mode: "normal",
+                  style: "",
+                  text: " ",
+                  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
+        }
+      };
+      const newEditor = createEditor();
+      const parsedEditorState = newEditor.parseEditorState(JSON.stringify(initialEditorState));
+      newEditor.setEditorState(parsedEditorState);
+      this.__caption = newEditor;
+    } else {
+      this.__caption = caption;
+    }
+  }
+  static getType() {
+    return "hint";
+  }
+  static clone(node) {
+    return new _Hint(node.__variant, node.__caption, node.__key);
+  }
+  static importJSON(serializedNode) {
+    return new _Hint(
+      serializedNode.variant,
+      // Change from type to variant
+      void 0
+    ).updateFromJSON(serializedNode);
+  }
+  setVariant(variant) {
+    const self = this.getWritable();
+    self.__variant = variant;
+    return self;
+  }
+  createDOM() {
+    const element = document.createElement("div");
+    element.className = `hint-${this.__type}`;
+    return element;
+  }
+  updateFromJSON(serializedNode) {
+    super.updateFromJSON(serializedNode);
+    const nestedEditor = this.__caption;
+    const editorState = nestedEditor.parseEditorState(serializedNode.caption.editorState);
+    if (!editorState.isEmpty()) {
+      nestedEditor.setEditorState(editorState);
+    }
+    return this;
+  }
+  exportJSON() {
+    return __spreadProps(__spreadValues({}, super.exportJSON()), {
+      variant: this.__variant,
+      type: "hint",
+      caption: this.__caption.toJSON()
+    });
+  }
+  updateDOM() {
+    return false;
+  }
+  decorate() {
+    return /* @__PURE__ */ React.createElement(Suspense, { fallback: null }, /* @__PURE__ */ React.createElement(
+      HintComponent,
+      {
+        type: this.__variant,
+        captionEditor: this.__caption,
+        nodeKey: this.getKey()
+      }
+    ));
+  }
+};
+function $isHintNode(node) {
+  return node instanceof Hint;
+}
+function $createHintNode(type) {
+  return new Hint(type);
+}
+var INSERT_HINT_COMMAND = createCommand();
+function $insertHintNode(type) {
+  const selection = $getSelection();
+  if ($isRangeSelection(selection)) {
+    const hintNode = $createHintNode(type);
+    selection.insertNodes([hintNode]);
+  }
+}
+function HintPlugin() {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    if (!editor.hasNodes([Hint])) {
+      throw new Error("Hint: Hint not registered on editor");
+    }
+  }, [editor]);
+  useEffect(() => {
+    return editor.registerCommand(
+      INSERT_HINT_COMMAND,
+      (payload, editor2) => {
+        editor2.update(() => {
+          $insertHintNode(payload);
+        });
+        return true;
+      },
+      COMMAND_PRIORITY_LOW
+    );
+  }, [editor]);
+  return null;
+}
+
+export {
+  Hint,
+  $isHintNode,
+  INSERT_HINT_COMMAND,
+  HintPlugin
+};