quasar-ui-danx 0.5.0 → 0.5.1

package/src/components/Utility/Markdown/MarkdownEditor.vue

@@ -0,0 +1,228 @@
+<template>
+  <div class="dx-markdown-editor" :class="{ 'is-readonly': readonly }">
+    <div class="dx-markdown-editor-body" @contextmenu="contextMenu.show">
+      <!-- Floating line type menu positioned next to current block -->
+      <div
+        ref="menuContainerRef"
+        class="dx-line-type-menu-container"
+        :style="lineTypeMenu.menuStyle.value"
+      >
+        <LineTypeMenu
+          :current-type="lineTypeMenu.currentLineType.value"
+          @change="lineTypeMenu.onLineTypeChange"
+        />
+      </div>
+
+      <MarkdownEditorContent
+        ref="contentRef"
+        :html="editor.renderedHtml.value"
+        :readonly="readonly"
+        :placeholder="placeholder"
+        @input="editor.onInput"
+        @keydown="editor.onKeyDown"
+        @blur="editor.onBlur"
+      />
+    </div>
+
+    <MarkdownEditorFooter
+      :char-count="editor.charCount.value"
+      @show-hotkeys="editor.showHotkeyHelp"
+    />
+
+    <HotkeyHelpPopover
+      v-if="editor.isShowingHotkeyHelp.value"
+      :hotkeys="editor.hotkeyDefinitions.value"
+      @close="editor.hideHotkeyHelp"
+    />
+
+    <LinkPopover
+      v-if="linkPopover.isVisible.value"
+      :position="linkPopover.position.value"
+      :existing-url="linkPopover.existingUrl.value"
+      :selected-text="linkPopover.selectedText.value"
+      @submit="linkPopover.submit"
+      @cancel="linkPopover.cancel"
+    />
+
+    <TablePopover
+      v-if="tablePopover.isVisible.value"
+      :position="tablePopover.position.value"
+      @submit="tablePopover.submit"
+      @cancel="tablePopover.cancel"
+    />
+
+    <ContextMenu
+      v-if="contextMenu.isVisible.value"
+      :position="contextMenu.position.value"
+      :items="contextMenu.items.value"
+      @close="contextMenu.hide"
+    />
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, onMounted, onUnmounted, ref, watch } from "vue";
+import { useContextMenu } from "../../../composables/markdown/features/useContextMenu";
+import { useFocusTracking } from "../../../composables/markdown/features/useFocusTracking";
+import { useLineTypeMenu } from "../../../composables/markdown/features/useLineTypeMenu";
+import { useLinkPopover, useTablePopover } from "../../../composables/markdown/features/usePopoverManager";
+import { useMarkdownEditor } from "../../../composables/markdown/useMarkdownEditor";
+import ContextMenu from "./ContextMenu.vue";
+import HotkeyHelpPopover from "./HotkeyHelpPopover.vue";
+import LineTypeMenu from "./LineTypeMenu.vue";
+import LinkPopover from "./LinkPopover.vue";
+import MarkdownEditorContent from "./MarkdownEditorContent.vue";
+import MarkdownEditorFooter from "./MarkdownEditorFooter.vue";
+import TablePopover from "./TablePopover.vue";
+
+export interface MarkdownEditorProps {
+  modelValue?: string;
+  placeholder?: string;
+  readonly?: boolean;
+  minHeight?: string;
+  maxHeight?: string;
+}
+
+const props = withDefaults(defineProps<MarkdownEditorProps>(), {
+  modelValue: "",
+  placeholder: "Start typing...",
+  readonly: false,
+  minHeight: "100px",
+  maxHeight: "none"
+});
+
+const emit = defineEmits<{
+  "update:modelValue": [value: string];
+}>();
+
+// Reference to the content component
+const contentRef = ref<InstanceType<typeof MarkdownEditorContent> | null>(null);
+
+// Reference to the menu container for focus handling
+const menuContainerRef = ref<HTMLElement | null>(null);
+
+// Get the actual HTMLElement from the content component
+const contentElementRef = computed(() => contentRef.value?.containerRef || null);
+
+// Initialize popover managers
+const linkPopover = useLinkPopover();
+const tablePopover = useTablePopover();
+
+// Initialize the markdown editor composable
+const editor = useMarkdownEditor({
+  contentRef: contentElementRef,
+  initialValue: props.modelValue,
+  onEmitValue: (markdown: string) => {
+    emit("update:modelValue", markdown);
+  },
+  onShowLinkPopover: linkPopover.show,
+  onShowTablePopover: tablePopover.show
+});
+
+// Initialize focus tracking
+const focusTracking = useFocusTracking({
+  contentRef: contentElementRef,
+  menuContainerRef,
+  onSelectionChange: () => lineTypeMenu.updatePositionAndState()
+});
+
+// Initialize line type menu
+const lineTypeMenu = useLineTypeMenu({
+  contentRef: contentElementRef,
+  editor,
+  isEditorFocused: focusTracking.isEditorFocused
+});
+
+// Initialize context menu
+const contextMenu = useContextMenu({
+  editor,
+  readonly: computed(() => props.readonly)
+});
+
+// Setup line type menu listeners on mount
+onMounted(() => {
+  lineTypeMenu.setupListeners();
+});
+
+// Cleanup line type menu listeners on unmount
+onUnmounted(() => {
+  lineTypeMenu.cleanupListeners();
+});
+
+// Watch for external value changes
+watch(
+  () => props.modelValue,
+  (newValue) => {
+    // Skip if this change originated from the editor itself (internal update)
+    // This prevents cursor jumping when the watch triggers after typing
+    if (editor.isInternalUpdate.value) {
+      editor.isInternalUpdate.value = false;
+      return;
+    }
+
+    // Only update if the value is different from current
+    if (newValue !== undefined) {
+      editor.setMarkdown(newValue);
+    }
+  }
+);
+
+// NOTE: Content is already initialized in useMarkdownEditor with initialValue.
+// The v-html binding renders it, and the MutationObserver mounts CodeViewers.
+// Calling setMarkdown again here would replace the DOM and cause race conditions
+// with CodeViewer mounting. Only call setMarkdown for external value changes.
+
+// Expose the editor for parent components that may need access
+defineExpose({
+  editor,
+  setMarkdown: editor.setMarkdown
+});
+</script>
+
+<style lang="scss">
+.dx-markdown-editor {
+  display: flex;
+  flex-direction: column;
+  width: 100%;
+  border-radius: 0.375rem;
+  overflow: hidden;
+
+  &.is-readonly {
+    .dx-markdown-editor-content {
+      cursor: default;
+    }
+
+    .dx-line-type-menu-container {
+      display: none;
+    }
+  }
+
+  // Body container with floating menu and content side by side
+  .dx-markdown-editor-body {
+    display: flex;
+    position: relative;
+    flex: 1;
+    overflow: visible;
+  }
+
+  // Floating line type menu container - positioned outside editor bounds
+  .dx-line-type-menu-container {
+    position: absolute;
+    left: -1.75rem;
+    z-index: 10;
+    width: 1.75rem;
+    display: flex;
+    align-items: flex-start;
+    justify-content: center;
+    padding-top: 0.25rem;
+    transition: top 0.1s ease-out, opacity 0.15s ease;
+  }
+
+  // Apply min/max height to content area (no left margin needed - menu is outside)
+  .dx-markdown-editor-content {
+    flex: 1;
+    min-height: v-bind(minHeight);
+    max-height: v-bind(maxHeight);
+  }
+}
+</style>

package/src/components/Utility/Markdown/MarkdownEditorContent.vue

@@ -0,0 +1,235 @@
+<template>
+  <div
+    ref="containerRef"
+    class="dx-markdown-editor-content dx-markdown-content"
+    :class="{ 'is-readonly': readonly, 'is-empty': isEmpty }"
+    :contenteditable="!readonly"
+    :data-placeholder="placeholder"
+    @input="$emit('input')"
+    @keydown="$emit('keydown', $event)"
+    @blur="$emit('blur')"
+    @click="handleClick"
+    v-html="html"
+  />
+</template>
+
+<script setup lang="ts">
+import { computed, ref } from "vue";
+
+export interface MarkdownEditorContentProps {
+  html: string;
+  readonly?: boolean;
+  placeholder?: string;
+}
+
+const props = withDefaults(defineProps<MarkdownEditorContentProps>(), {
+  readonly: false,
+  placeholder: "Start typing..."
+});
+
+defineEmits<{
+  input: [];
+  keydown: [event: KeyboardEvent];
+  blur: [];
+}>();
+
+const containerRef = ref<HTMLElement | null>(null);
+
+/**
+ * Find the anchor element if the click target is inside one
+ */
+function findLinkAncestor(node: Node | null): HTMLAnchorElement | null {
+  if (!node || !containerRef.value) return null;
+
+  let current: Node | null = node;
+  while (current && current !== containerRef.value) {
+    if (current.nodeType === Node.ELEMENT_NODE && (current as Element).tagName === "A") {
+      return current as HTMLAnchorElement;
+    }
+    current = current.parentNode;
+  }
+
+  return null;
+}
+
+/**
+ * Handle clicks in the editor content.
+ * Ctrl+Click (or Cmd+Click on Mac) opens links in a new tab.
+ */
+function handleClick(event: MouseEvent): void {
+  // Check if Ctrl (Windows/Linux) or Cmd (Mac) is held
+  const isModifierHeld = event.ctrlKey || event.metaKey;
+  if (!isModifierHeld) return;
+
+  // Find if the click was on or inside a link
+  const link = findLinkAncestor(event.target as Node);
+  if (!link) return;
+
+  const href = link.getAttribute("href");
+  if (!href) return;
+
+  // Prevent default behavior and open the link in a new tab
+  event.preventDefault();
+  event.stopPropagation();
+  window.open(href, "_blank", "noopener,noreferrer");
+}
+
+const isEmpty = computed(() => {
+  return !props.html || props.html === "<p></p>" || props.html === "<p><br></p>";
+});
+
+// Expose containerRef for parent component
+defineExpose({ containerRef });
+</script>
+
+<style lang="scss">
+.dx-markdown-editor-content {
+  min-height: 100px;
+  outline: none;
+  cursor: text;
+  border: 2px solid transparent;
+  border-radius: 0.375rem 0.375rem 0 0;
+  padding: 1rem;
+  background-color: #1e1e1e;
+  color: #d4d4d4;
+  transition: border-color 0.2s ease;
+  overflow: auto;
+
+  &:focus {
+    border-color: rgba(86, 156, 214, 0.6);
+  }
+
+  &:hover:not(:focus):not(.is-readonly) {
+    border-color: rgba(86, 156, 214, 0.3);
+  }
+
+  &.is-readonly {
+    cursor: default;
+    border-color: transparent;
+  }
+
+  // Placeholder styling when empty
+  &.is-empty::before {
+    content: attr(data-placeholder);
+    color: #6b7280;
+    pointer-events: none;
+    position: absolute;
+  }
+
+  &.is-empty {
+    position: relative;
+  }
+
+  // Caret color
+  caret-color: #d4d4d4;
+
+  // Link styling - show pointer cursor and hint for Ctrl+Click
+  a {
+    cursor: pointer;
+    position: relative;
+
+    &:hover::after {
+      content: "Ctrl+Click to open";
+      position: absolute;
+      bottom: 100%;
+      left: 50%;
+      transform: translateX(-50%);
+      background: #374151;
+      color: #d1d5db;
+      padding: 0.25rem 0.5rem;
+      border-radius: 0.25rem;
+      font-size: 0.75rem;
+      white-space: nowrap;
+      z-index: 10;
+      pointer-events: none;
+      opacity: 0;
+      animation: fadeIn 0.2s ease 0.5s forwards;
+    }
+  }
+
+  @keyframes fadeIn {
+    to {
+      opacity: 1;
+    }
+  }
+
+  // Alternating styles for nested ordered lists
+  // Level 1: decimal (1, 2, 3)
+  ol {
+    list-style-type: decimal;
+
+    // Level 2: lower-roman (i, ii, iii)
+    ol {
+      list-style-type: lower-roman;
+
+      // Level 3: lower-alpha (a, b, c)
+      ol {
+        list-style-type: lower-alpha;
+
+        // Level 4+: cycle back to decimal
+        ol {
+          list-style-type: decimal;
+
+          ol {
+            list-style-type: lower-roman;
+
+            ol {
+              list-style-type: lower-alpha;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Alternating styles for nested unordered lists
+  // Level 1: disc
+  ul {
+    list-style-type: disc;
+
+    // Level 2: circle
+    ul {
+      list-style-type: circle;
+
+      // Level 3: square
+      ul {
+        list-style-type: square;
+
+        // Level 4+: cycle back to disc
+        ul {
+          list-style-type: disc;
+
+          ul {
+            list-style-type: circle;
+
+            ul {
+              list-style-type: square;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Code block wrapper styling - distinct background to separate from editor content
+  .code-block-wrapper {
+    background: #0d1117;
+    border-radius: 0.375rem;
+    margin: 0.5rem 0;
+    border: 1px solid #30363d;
+
+    // Override CodeViewer backgrounds to be transparent so wrapper controls it
+    .dx-code-viewer {
+      .code-content {
+        background: transparent;
+        border-radius: 0.375rem 0.375rem 0 0;
+      }
+
+      .code-footer {
+        background: #161b22;
+        border-radius: 0 0 0.375rem 0.375rem;
+      }
+    }
+  }
+}
+</style>

package/src/components/Utility/Markdown/MarkdownEditorFooter.vue

@@ -0,0 +1,50 @@
+<template>
+  <div class="dx-markdown-editor-footer flex items-center justify-between px-2 py-1">
+    <span class="char-count text-xs text-gray-500">
+      {{ charCount.toLocaleString() }} chars
+    </span>
+    <button
+      class="hotkey-help-btn text-gray-500 hover:text-gray-300 transition-colors p-1 rounded"
+      title="Keyboard shortcuts (Ctrl+?)"
+      type="button"
+      @click="$emit('show-hotkeys')"
+    >
+      <KeyboardIcon class="w-4 h-4" />
+    </button>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { FaSolidKeyboard as KeyboardIcon } from "danx-icon";
+
+export interface MarkdownEditorFooterProps {
+  charCount: number;
+}
+
+defineProps<MarkdownEditorFooterProps>();
+
+defineEmits<{
+  "show-hotkeys": [];
+}>();
+</script>
+
+<style lang="scss">
+.dx-markdown-editor-footer {
+  background-color: #252526;
+  border-radius: 0 0 0.375rem 0.375rem;
+  flex-shrink: 0;
+
+  .hotkey-help-btn {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: transparent;
+    border: none;
+    cursor: pointer;
+
+    &:hover {
+      background-color: rgba(255, 255, 255, 0.1);
+    }
+  }
+}
+</style>