@cgboiler/biz-basic 1.0.53 → 1.0.55

package/lib/rich-text-editor/menu-system/hooks/use-mobile.d.ts

@@ -0,0 +1 @@
+export declare function useIsMobile(breakpoint?: number): import("vue").Ref<boolean, boolean>;

package/lib/rich-text-editor/menu-system/hooks/use-mobile.js

@@ -0,0 +1,39 @@
+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);
+var stdin_exports = {};
+__export(stdin_exports, {
+  useIsMobile: () => useIsMobile
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+function useIsMobile(breakpoint = 768) {
+  const isMobile = (0, import_vue.ref)(false);
+  const checkMobile = () => {
+    isMobile.value = window.innerWidth < breakpoint;
+  };
+  (0, import_vue.onMounted)(() => {
+    const mql = window.matchMedia(`(max-width: ${breakpoint - 1}px)`);
+    mql.addEventListener("change", checkMobile);
+    checkMobile();
+  });
+  (0, import_vue.onBeforeUnmount)(() => {
+    const mql = window.matchMedia(`(max-width: ${breakpoint - 1}px)`);
+    mql.removeEventListener("change", checkMobile);
+  });
+  return isMobile;
+}

package/lib/rich-text-editor/menu-system/hooks/use-text-align.d.ts

@@ -0,0 +1,28 @@
+import type { Editor } from '@tiptap/vue-3';
+export type TextAlign = 'left' | 'center' | 'right' | 'justify';
+export interface UseTextAlignConfig {
+    editor: any;
+    align: TextAlign;
+    hideWhenUnavailable?: boolean;
+    onAligned?: () => void;
+}
+export declare const TEXT_ALIGN_SHORTCUT_KEYS: Record<TextAlign, string>;
+export declare const textAlignIcons: any;
+export declare const textAlignLabels: Record<TextAlign, string>;
+export declare function canSetTextAlign(editor: Editor | null, align: TextAlign): boolean;
+export declare function isTextAlignActive(editor: Editor | null, align: TextAlign): boolean;
+export declare function setTextAlign(editor: Editor | null, align: TextAlign): boolean;
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+    align: TextAlign;
+}): boolean;
+export declare function useTextAlign(config: UseTextAlignConfig): {
+    isVisible: import("vue").Ref<boolean, boolean>;
+    isActive: import("vue").Ref<boolean, boolean>;
+    handleTextAlign: () => void;
+    canAlign: import("vue").Ref<boolean, boolean>;
+    label: string;
+    shortcutKeys: string;
+    Icon: any;
+};

package/lib/rich-text-editor/menu-system/hooks/use-text-align.js

@@ -0,0 +1,132 @@
+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);
+var stdin_exports = {};
+__export(stdin_exports, {
+  TEXT_ALIGN_SHORTCUT_KEYS: () => TEXT_ALIGN_SHORTCUT_KEYS,
+  canSetTextAlign: () => canSetTextAlign,
+  isTextAlignActive: () => isTextAlignActive,
+  setTextAlign: () => setTextAlign,
+  shouldShowButton: () => shouldShowButton,
+  textAlignIcons: () => textAlignIcons,
+  textAlignLabels: () => textAlignLabels,
+  useTextAlign: () => useTextAlign
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_tiptap_utils = require("../utils/tiptap-utils");
+var import_icons = require("../icons");
+const TEXT_ALIGN_SHORTCUT_KEYS = {
+  left: "mod+shift+l",
+  center: "mod+shift+e",
+  right: "mod+shift+r",
+  justify: "mod+shift+j"
+};
+const textAlignIcons = {
+  left: import_icons.AlignLeftIcon,
+  center: import_icons.AlignCenterIcon,
+  right: import_icons.AlignRightIcon,
+  justify: import_icons.AlignJustifyIcon
+};
+const textAlignLabels = {
+  left: "Align left",
+  center: "Align center",
+  right: "Align right",
+  justify: "Align justify"
+};
+function canSetTextAlign(editor, align) {
+  if (!editor || !editor.isEditable)
+    return false;
+  if (!(0, import_tiptap_utils.isExtensionAvailable)(editor, "textAlign") || (0, import_tiptap_utils.isNodeTypeSelected)(editor, ["image", "horizontalRule"]))
+    return false;
+  return editor.can().setTextAlign(align);
+}
+function isTextAlignActive(editor, align) {
+  if (!editor || !editor.isEditable)
+    return false;
+  return editor.isActive({ textAlign: align });
+}
+function setTextAlign(editor, align) {
+  if (!editor || !editor.isEditable)
+    return false;
+  if (!canSetTextAlign(editor, align))
+    return false;
+  return editor.chain().focus().setTextAlign(align).run();
+}
+function shouldShowButton(props) {
+  const { editor, hideWhenUnavailable, align } = props;
+  if (!editor || !editor.isEditable)
+    return false;
+  if (!(0, import_tiptap_utils.isExtensionAvailable)(editor, "textAlign"))
+    return false;
+  if (hideWhenUnavailable && !editor.isActive("code")) {
+    return canSetTextAlign(editor, align);
+  }
+  return true;
+}
+function useTextAlign(config) {
+  const { align, hideWhenUnavailable = false, onAligned } = config;
+  const isVisible = (0, import_vue.ref)(true);
+  const isActive = (0, import_vue.ref)(false);
+  const canAlign = (0, import_vue.ref)(false);
+  const getEditor = () => {
+    const editor = config.editor;
+    return editor && "value" in editor ? editor.value : editor;
+  };
+  const updateState = () => {
+    const editor = getEditor();
+    if (!editor || !editor.isEditable) {
+      isVisible.value = false;
+      isActive.value = false;
+      canAlign.value = false;
+      return;
+    }
+    isActive.value = isTextAlignActive(editor, align);
+    canAlign.value = canSetTextAlign(editor, align);
+    isVisible.value = shouldShowButton({ editor, align, hideWhenUnavailable });
+  };
+  (0, import_vue.watch)(
+    () => getEditor(),
+    (editor) => {
+      if (!editor)
+        return;
+      updateState();
+      editor.on("selectionUpdate", updateState);
+      editor.on("transaction", updateState);
+      (0, import_vue.onBeforeUnmount)(() => {
+        editor.off("selectionUpdate", updateState);
+        editor.off("transaction", updateState);
+      });
+    },
+    { immediate: true }
+  );
+  const handleTextAlign = () => {
+    const editor = getEditor();
+    if (setTextAlign(editor, align)) {
+      onAligned == null ? void 0 : onAligned();
+    }
+  };
+  return {
+    isVisible,
+    isActive,
+    handleTextAlign,
+    canAlign,
+    label: textAlignLabels[align],
+    shortcutKeys: TEXT_ALIGN_SHORTCUT_KEYS[align],
+    Icon: textAlignIcons[align]
+  };
+}

package/lib/rich-text-editor/menu-system/hooks/use-throttled-callback.d.ts

@@ -0,0 +1,8 @@
+export declare function useThrottledCallback<T extends (...args: any[]) => any>(fn: T, wait?: number, options?: {
+    leading?: boolean;
+    trailing?: boolean;
+}): T & {
+    cancel: () => void;
+    flush: () => void;
+};
+export default useThrottledCallback;

package/lib/rich-text-editor/menu-system/hooks/use-throttled-callback.js

@@ -0,0 +1,64 @@
+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);
+var stdin_exports = {};
+__export(stdin_exports, {
+  default: () => stdin_default,
+  useThrottledCallback: () => useThrottledCallback
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+const throttle = (fn, wait, options = { leading: false, trailing: true }) => {
+  let timeout = null;
+  let previous = 0;
+  const throttled = function(...args) {
+    const now = Date.now();
+    if (!previous && options.leading === false)
+      previous = now;
+    const remaining = wait - (now - previous);
+    if (remaining <= 0 || remaining > wait) {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+      previous = now;
+      fn.apply(this, args);
+    } else if (!timeout && options.trailing !== false) {
+      timeout = setTimeout(() => {
+        previous = options.leading === false ? 0 : Date.now();
+        timeout = null;
+        fn.apply(this, args);
+      }, remaining);
+    }
+  };
+  throttled.cancel = () => {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = null;
+    }
+    previous = 0;
+  };
+  return throttled;
+};
+function useThrottledCallback(fn, wait = 250, options = { leading: false, trailing: true }) {
+  const throttled = throttle(fn, wait, options);
+  (0, import_vue.onBeforeUnmount)(() => {
+    throttled.cancel();
+  });
+  return throttled;
+}
+var stdin_default = useThrottledCallback;

package/lib/rich-text-editor/menu-system/hooks/use-undo-redo.d.ts

@@ -0,0 +1,60 @@
+import type { Editor } from '@tiptap/vue-3';
+export type UndoRedoAction = 'undo' | 'redo';
+export interface UseUndoRedoConfig {
+    editor: any;
+    action: UndoRedoAction;
+    hideWhenUnavailable?: boolean;
+    onExecuted?: () => void;
+}
+export declare const UNDO_REDO_SHORTCUT_KEYS: Record<UndoRedoAction, string>;
+export declare const historyActionLabels: Record<UndoRedoAction, string>;
+export declare const historyIcons: {
+    undo: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        className: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        className: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        className: string;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    redo: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        className: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        className: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        className: string;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+};
+export declare function canExecuteUndoRedoAction(editor: Editor | null, action: UndoRedoAction): boolean;
+export declare function executeUndoRedoAction(editor: Editor | null, action: UndoRedoAction): boolean;
+export declare function useUndoRedo(config: UseUndoRedoConfig): {
+    isVisible: import("vue").Ref<boolean, boolean>;
+    handleAction: () => boolean;
+    canExecute: import("vue").Ref<boolean, boolean>;
+    label: string;
+    shortcutKeys: string;
+    Icon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        className: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        className: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        className: string;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+};

package/lib/rich-text-editor/menu-system/hooks/use-undo-redo.js

@@ -0,0 +1,115 @@
+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);
+var stdin_exports = {};
+__export(stdin_exports, {
+  UNDO_REDO_SHORTCUT_KEYS: () => UNDO_REDO_SHORTCUT_KEYS,
+  canExecuteUndoRedoAction: () => canExecuteUndoRedoAction,
+  executeUndoRedoAction: () => executeUndoRedoAction,
+  historyActionLabels: () => historyActionLabels,
+  historyIcons: () => historyIcons,
+  useUndoRedo: () => useUndoRedo
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_tiptap_utils = require("../utils/tiptap-utils");
+var import_icons = require("../icons");
+const UNDO_REDO_SHORTCUT_KEYS = {
+  undo: "mod+z",
+  redo: "mod+shift+z"
+};
+const historyActionLabels = {
+  undo: "Undo",
+  redo: "Redo"
+};
+const historyIcons = {
+  undo: import_icons.Undo2Icon,
+  redo: import_icons.Redo2Icon
+};
+function canExecuteUndoRedoAction(editor, action) {
+  if (!editor || !editor.isEditable)
+    return false;
+  if ((0, import_tiptap_utils.isNodeTypeSelected)(editor, ["image"]))
+    return false;
+  return action === "undo" ? editor.can().undo() : editor.can().redo();
+}
+function executeUndoRedoAction(editor, action) {
+  if (!editor || !editor.isEditable)
+    return false;
+  if (!canExecuteUndoRedoAction(editor, action))
+    return false;
+  const chain = editor.chain().focus();
+  return action === "undo" ? chain.undo().run() : chain.redo().run();
+}
+function useUndoRedo(config) {
+  const { action, hideWhenUnavailable = false, onExecuted } = config;
+  const isVisible = (0, import_vue.ref)(true);
+  const getEditor = () => {
+    const editor = config.editor;
+    return editor && "value" in editor ? editor.value : editor;
+  };
+  const handleUpdate = () => {
+    const editor = getEditor();
+    if (!editor || !editor.isEditable) {
+      isVisible.value = false;
+      return;
+    }
+    if (hideWhenUnavailable && !editor.isActive("code")) {
+      isVisible.value = canExecuteUndoRedoAction(editor, action);
+    } else {
+      isVisible.value = true;
+    }
+  };
+  const handleAction = () => {
+    const editor = getEditor();
+    if (!editor)
+      return false;
+    const success = executeUndoRedoAction(editor, action);
+    if (success) {
+      onExecuted == null ? void 0 : onExecuted();
+    }
+    return success;
+  };
+  const canExecute = (0, import_vue.ref)(false);
+  const updateCanExecute = () => {
+    canExecute.value = canExecuteUndoRedoAction(getEditor(), action);
+  };
+  (0, import_vue.watch)(
+    () => getEditor(),
+    (editor) => {
+      if (!editor)
+        return;
+      handleUpdate();
+      updateCanExecute();
+      editor.on("transaction", handleUpdate);
+      editor.on("transaction", updateCanExecute);
+      (0, import_vue.onBeforeUnmount)(() => {
+        editor.off("transaction", handleUpdate);
+        editor.off("transaction", updateCanExecute);
+      });
+    },
+    { immediate: true }
+  );
+  return {
+    isVisible,
+    handleAction,
+    canExecute,
+    label: historyActionLabels[action],
+    shortcutKeys: UNDO_REDO_SHORTCUT_KEYS[action],
+    Icon: historyIcons[action]
+  };
+}

package/lib/rich-text-editor/menu-system/hooks/use-window-size.d.ts

@@ -0,0 +1,21 @@
+export interface WindowSizeState {
+    width: number;
+    height: number;
+    offsetTop: number;
+    offsetLeft: number;
+    scale: number;
+}
+export declare function useWindowSize(): WindowSizeState;
+export declare function useWindowSizeStore(): import("vue").Ref<{
+    width: number;
+    height: number;
+    offsetTop: number;
+    offsetLeft: number;
+    scale: number;
+}, WindowSizeState | {
+    width: number;
+    height: number;
+    offsetTop: number;
+    offsetLeft: number;
+    scale: number;
+}>;

package/lib/rich-text-editor/menu-system/hooks/use-window-size.js

@@ -0,0 +1,93 @@
+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);
+var stdin_exports = {};
+__export(stdin_exports, {
+  useWindowSize: () => useWindowSize,
+  useWindowSizeStore: () => useWindowSizeStore
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_use_throttled_callback = require("./use-throttled-callback");
+function useWindowSize() {
+  const windowSize = (0, import_vue.ref)({
+    width: 0,
+    height: 0,
+    offsetTop: 0,
+    offsetLeft: 0,
+    scale: 0
+  });
+  const handleViewportChange = (0, import_use_throttled_callback.useThrottledCallback)(() => {
+    if (typeof window === "undefined")
+      return;
+    const vp = window.visualViewport;
+    if (!vp)
+      return;
+    const { width = 0, height = 0, offsetTop = 0, offsetLeft = 0, scale = 0 } = vp;
+    if (width === windowSize.value.width && height === windowSize.value.height && offsetTop === windowSize.value.offsetTop && offsetLeft === windowSize.value.offsetLeft && scale === windowSize.value.scale) {
+      return;
+    }
+    windowSize.value = { width, height, offsetTop, offsetLeft, scale };
+  }, 200);
+  (0, import_vue.onMounted)(() => {
+    const visualViewport = window.visualViewport;
+    if (!visualViewport)
+      return;
+    visualViewport.addEventListener("resize", handleViewportChange);
+    handleViewportChange();
+  });
+  (0, import_vue.onBeforeUnmount)(() => {
+    const visualViewport = window.visualViewport;
+    if (visualViewport) {
+      visualViewport.removeEventListener("resize", handleViewportChange);
+    }
+  });
+  return windowSize.value;
+}
+function useWindowSizeStore() {
+  const windowSize = (0, import_vue.ref)({
+    width: typeof window !== "undefined" ? window.innerWidth : 0,
+    height: typeof window !== "undefined" ? window.innerHeight : 0,
+    offsetTop: 0,
+    offsetLeft: 0,
+    scale: 1
+  });
+  const handleViewportChange = (0, import_use_throttled_callback.useThrottledCallback)(() => {
+    if (typeof window === "undefined")
+      return;
+    const vp = window.visualViewport;
+    if (!vp)
+      return;
+    windowSize.value = {
+      width: vp.width,
+      height: vp.height,
+      offsetTop: vp.offsetTop,
+      offsetLeft: vp.offsetLeft,
+      scale: vp.scale
+    };
+  }, 200);
+  (0, import_vue.onMounted)(() => {
+    var _a;
+    (_a = window.visualViewport) == null ? void 0 : _a.addEventListener("resize", handleViewportChange);
+    handleViewportChange();
+  });
+  (0, import_vue.onBeforeUnmount)(() => {
+    var _a;
+    (_a = window.visualViewport) == null ? void 0 : _a.removeEventListener("resize", handleViewportChange);
+  });
+  return windowSize;
+}

package/lib/rich-text-editor/menu-system/icons/_atomic.css

@@ -0,0 +1,32 @@
+
+.cgx-atm .flex {
+  align-items: initial;
+  flex-direction: initial;
+  justify-content: initial;
+  flex-wrap: initial;
+}
+.cgx-atm .flex-row {
+  flex-direction: row;
+}
+.cgx-atm .flex-col {
+  flex-direction: column;
+}
+.cgx-atm .justify-center {
+  justify-content: center;
+}
+.cgx-atm .justify-between {
+  justify-content: space-between;
+}
+.cgx-atm .justify-around {
+  justify-content: space-around;
+}
+.cgx-atm .justify-end {
+  justify-content: flex-end;
+}
+.cgx-atm .items-center {
+  align-items: center;
+}
+.cgx-atm .flex-wrap {
+  flex-wrap: wrap;
+}
+