@shwfed/nuxt 0.10.3 → 0.10.5

package/dist/runtime/components/ui/button-configurator/ButtonConfiguratorDialog.vue.d.ts

@@ -0,0 +1,97 @@
+import { type ButtonConfig } from '../buttons/schema.js';
+type __VLS_Props = {
+    config: ButtonConfig;
+};
+type __VLS_ModelProps = {
+    'open'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+    confirm: (args_0: Readonly<{
+        groups: readonly Readonly<{
+            id: string;
+            items: readonly (Readonly<{
+                id: string;
+                title: readonly {
+                    locale: "zh" | "ja" | "en" | "ko";
+                    message: string;
+                }[];
+                tooltip?: readonly {
+                    locale: "zh" | "ja" | "en" | "ko";
+                    message: string;
+                }[] | undefined;
+                icon?: string | undefined;
+                variant?: "default" | "destructive" | "primary" | "ghost" | undefined;
+                hideTitle?: boolean | undefined;
+            }> | Readonly<{
+                id: string;
+                title: readonly {
+                    locale: "zh" | "ja" | "en" | "ko";
+                    message: string;
+                }[];
+                items: readonly Readonly<{
+                    id: string;
+                    title: readonly {
+                        locale: "zh" | "ja" | "en" | "ko";
+                        message: string;
+                    }[];
+                    tooltip?: readonly {
+                        locale: "zh" | "ja" | "en" | "ko";
+                        message: string;
+                    }[] | undefined;
+                    icon?: string | undefined;
+                    variant?: "default" | "destructive" | "primary" | "ghost" | undefined;
+                }>[];
+                icon?: string | undefined;
+            }>)[];
+        }>[];
+        gap?: number | undefined;
+        style?: string | undefined;
+    }>) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onConfirm?: ((args_0: Readonly<{
+        groups: readonly Readonly<{
+            id: string;
+            items: readonly (Readonly<{
+                id: string;
+                title: readonly {
+                    locale: "zh" | "ja" | "en" | "ko";
+                    message: string;
+                }[];
+                tooltip?: readonly {
+                    locale: "zh" | "ja" | "en" | "ko";
+                    message: string;
+                }[] | undefined;
+                icon?: string | undefined;
+                variant?: "default" | "destructive" | "primary" | "ghost" | undefined;
+                hideTitle?: boolean | undefined;
+            }> | Readonly<{
+                id: string;
+                title: readonly {
+                    locale: "zh" | "ja" | "en" | "ko";
+                    message: string;
+                }[];
+                items: readonly Readonly<{
+                    id: string;
+                    title: readonly {
+                        locale: "zh" | "ja" | "en" | "ko";
+                        message: string;
+                    }[];
+                    tooltip?: readonly {
+                        locale: "zh" | "ja" | "en" | "ko";
+                        message: string;
+                    }[] | undefined;
+                    icon?: string | undefined;
+                    variant?: "default" | "destructive" | "primary" | "ghost" | undefined;
+                }>[];
+                icon?: string | undefined;
+            }>)[];
+        }>[];
+        gap?: number | undefined;
+        style?: string | undefined;
+    }>) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/ui/button-configurator/menu.d.ts

@@ -0,0 +1,48 @@
+import type { LocaleValue } from '../../../utils/coders.js';
+import type { ButtonAction, ButtonDropdown, ButtonGroup } from '../buttons/schema.js';
+export type ButtonConfiguratorDraftNodeData = Readonly<{
+    type: 'group';
+    id: string;
+}> | Readonly<{
+    type: 'button';
+    id: string;
+    title: LocaleValue;
+    tooltip?: LocaleValue;
+    icon?: string;
+    variant?: ButtonAction['variant'];
+    hideTitle?: boolean;
+}> | Readonly<{
+    type: 'dropdown';
+    id: string;
+    title: LocaleValue;
+    icon?: string;
+}>;
+export type ButtonConfiguratorDraftNode = Readonly<{
+    itemId: string;
+    parentItemId?: string;
+    childItemIds: Array<string>;
+    item: ButtonConfiguratorDraftNodeData;
+}>;
+export type ButtonConfiguratorDraftTree = Readonly<{
+    rootItemIds: Array<string>;
+    nodes: Array<ButtonConfiguratorDraftNode>;
+}>;
+export type ButtonConfiguratorFlattenedItem = Readonly<{
+    itemId: string;
+    depth: number;
+    item: ButtonConfiguratorDraftNodeData;
+}>;
+export declare function createButtonConfiguratorGroupNode(group?: ButtonGroup, createItemId?: () => string): ButtonConfiguratorDraftNode;
+export declare function createButtonConfiguratorButtonNode(button?: ButtonAction, createItemId?: () => string): ButtonConfiguratorDraftNode;
+export declare function createButtonConfiguratorDropdownNode(dropdown?: ButtonDropdown, createItemId?: () => string): ButtonConfiguratorDraftNode;
+export declare function buildButtonConfiguratorTree(groups: ReadonlyArray<ButtonGroup>, createItemId?: () => string): ButtonConfiguratorDraftTree;
+export declare function getButtonConfiguratorNode(tree: ButtonConfiguratorDraftTree, itemId: string): ButtonConfiguratorDraftNode | undefined;
+export declare function flattenButtonConfiguratorTree(tree: ButtonConfiguratorDraftTree): Array<ButtonConfiguratorFlattenedItem>;
+export declare function updateButtonConfiguratorNode(tree: ButtonConfiguratorDraftTree, itemId: string, update: (item: ButtonConfiguratorDraftNodeData) => ButtonConfiguratorDraftNodeData): ButtonConfiguratorDraftTree;
+export declare function insertButtonConfiguratorRootNode(tree: ButtonConfiguratorDraftTree, node: ButtonConfiguratorDraftNode, index?: number): ButtonConfiguratorDraftTree;
+export declare function insertButtonConfiguratorChildNode(tree: ButtonConfiguratorDraftTree, parentItemId: string, node: ButtonConfiguratorDraftNode, index?: number): ButtonConfiguratorDraftTree;
+export declare function moveButtonConfiguratorNodeToParent(tree: ButtonConfiguratorDraftTree, itemId: string, parentItemId: string | undefined, index?: number): ButtonConfiguratorDraftTree;
+export declare function moveButtonConfiguratorSibling(tree: ButtonConfiguratorDraftTree, parentItemId: string | undefined, oldIndex: number, newIndex: number): ButtonConfiguratorDraftTree;
+export declare function removeButtonConfiguratorSubtree(tree: ButtonConfiguratorDraftTree, itemId: string): ButtonConfiguratorDraftTree;
+export declare function materializeButtonConfiguratorTree(tree: ButtonConfiguratorDraftTree): Array<ButtonGroup>;
+export declare function isButtonConfiguratorNodeContainer(node: ButtonConfiguratorDraftNode | undefined): boolean;

package/dist/runtime/components/ui/button-configurator/menu.js

@@ -0,0 +1,381 @@
+function insertItemId(itemIds, itemId, index = itemIds.length) {
+  const nextItemIds = itemIds.slice();
+  const normalizedIndex = Math.min(Math.max(index, 0), nextItemIds.length);
+  nextItemIds.splice(normalizedIndex, 0, itemId);
+  return nextItemIds;
+}
+function moveItemId(itemIds, oldIndex, newIndex) {
+  if (oldIndex < 0 || newIndex < 0 || oldIndex >= itemIds.length || newIndex >= itemIds.length) {
+    return itemIds.slice();
+  }
+  const nextItemIds = itemIds.slice();
+  const movedItemId = nextItemIds[oldIndex];
+  if (!movedItemId) {
+    return nextItemIds;
+  }
+  nextItemIds.splice(oldIndex, 1);
+  nextItemIds.splice(newIndex, 0, movedItemId);
+  return nextItemIds;
+}
+function replaceNode(tree, itemId, update) {
+  return {
+    ...tree,
+    nodes: tree.nodes.map((node) => node.itemId === itemId ? update(node) : node)
+  };
+}
+function updateSiblingIds(tree, parentItemId, update) {
+  if (!parentItemId) {
+    return {
+      ...tree,
+      rootItemIds: update(tree.rootItemIds)
+    };
+  }
+  return replaceNode(tree, parentItemId, (node) => ({
+    ...node,
+    childItemIds: update(node.childItemIds)
+  }));
+}
+function stripButton(button) {
+  const nextItem = {
+    type: "button",
+    id: button.id,
+    title: button.title
+  };
+  if (button.tooltip) {
+    nextItem.tooltip = button.tooltip;
+  }
+  if (button.icon) {
+    nextItem.icon = button.icon;
+  }
+  if (button.variant) {
+    nextItem.variant = button.variant;
+  }
+  if (button.hideTitle) {
+    nextItem.hideTitle = button.hideTitle;
+  }
+  return nextItem;
+}
+function stripDropdown(dropdown) {
+  const nextItem = {
+    type: "dropdown",
+    id: dropdown.id,
+    title: dropdown.title
+  };
+  if (dropdown.icon) {
+    nextItem.icon = dropdown.icon;
+  }
+  return nextItem;
+}
+function stripGroup(group) {
+  return {
+    type: "group",
+    id: group.id
+  };
+}
+export function createButtonConfiguratorGroupNode(group, createItemId) {
+  return {
+    itemId: createItemId?.() ?? crypto.randomUUID(),
+    childItemIds: [],
+    item: group ? stripGroup(group) : {
+      type: "group",
+      id: crypto.randomUUID()
+    }
+  };
+}
+export function createButtonConfiguratorButtonNode(button, createItemId) {
+  return {
+    itemId: createItemId?.() ?? crypto.randomUUID(),
+    childItemIds: [],
+    item: button ? stripButton(button) : {
+      type: "button",
+      id: crypto.randomUUID(),
+      title: [{ locale: "zh", message: "" }],
+      tooltip: [{ locale: "zh", message: "" }]
+    }
+  };
+}
+export function createButtonConfiguratorDropdownNode(dropdown, createItemId) {
+  return {
+    itemId: createItemId?.() ?? crypto.randomUUID(),
+    childItemIds: [],
+    item: dropdown ? stripDropdown(dropdown) : {
+      type: "dropdown",
+      id: crypto.randomUUID(),
+      title: [{ locale: "zh", message: "" }]
+    }
+  };
+}
+export function buildButtonConfiguratorTree(groups, createItemId) {
+  const nodes = [];
+  function visitButton(button, parentItemId) {
+    const itemId = createItemId?.() ?? crypto.randomUUID();
+    nodes.push({
+      itemId,
+      parentItemId,
+      childItemIds: [],
+      item: stripButton(button)
+    });
+    return itemId;
+  }
+  function visitDropdown(dropdown, parentItemId) {
+    const itemId = createItemId?.() ?? crypto.randomUUID();
+    const childItemIds = dropdown.items.map((button) => visitButton(button, itemId));
+    nodes.push({
+      itemId,
+      parentItemId,
+      childItemIds,
+      item: stripDropdown(dropdown)
+    });
+    return itemId;
+  }
+  function visitItem(item, parentItemId) {
+    if ("items" in item) {
+      return visitDropdown(item, parentItemId);
+    }
+    return visitButton(item, parentItemId);
+  }
+  function visitGroup(group) {
+    const itemId = createItemId?.() ?? crypto.randomUUID();
+    const childItemIds = group.items.map((item) => visitItem(item, itemId));
+    nodes.push({
+      itemId,
+      childItemIds,
+      item: stripGroup(group)
+    });
+    return itemId;
+  }
+  return {
+    rootItemIds: groups.map((group) => visitGroup(group)),
+    nodes
+  };
+}
+export function getButtonConfiguratorNode(tree, itemId) {
+  return tree.nodes.find((node) => node.itemId === itemId);
+}
+export function flattenButtonConfiguratorTree(tree) {
+  function visit(itemId, depth) {
+    const node = getButtonConfiguratorNode(tree, itemId);
+    if (!node) {
+      return [];
+    }
+    return [
+      {
+        itemId: node.itemId,
+        depth,
+        item: node.item
+      },
+      ...node.childItemIds.flatMap((childItemId) => visit(childItemId, depth + 1))
+    ];
+  }
+  return tree.rootItemIds.flatMap((itemId) => visit(itemId, 0));
+}
+export function updateButtonConfiguratorNode(tree, itemId, update) {
+  return replaceNode(tree, itemId, (node) => ({
+    ...node,
+    item: update(node.item)
+  }));
+}
+function canAttachNode(tree, itemId, parentItemId) {
+  const node = getButtonConfiguratorNode(tree, itemId);
+  if (!node) {
+    return false;
+  }
+  if (!parentItemId) {
+    return node.item.type === "group";
+  }
+  const parentNode = getButtonConfiguratorNode(tree, parentItemId);
+  if (!parentNode) {
+    return false;
+  }
+  if (parentNode.item.type === "group") {
+    return node.item.type === "button" || node.item.type === "dropdown";
+  }
+  if (parentNode.item.type === "dropdown") {
+    return node.item.type === "button";
+  }
+  return false;
+}
+function detachNode(tree, itemId) {
+  const node = getButtonConfiguratorNode(tree, itemId);
+  if (!node) {
+    return tree;
+  }
+  const detachedTree = updateSiblingIds(
+    tree,
+    node.parentItemId,
+    (itemIds) => itemIds.filter((currentItemId) => currentItemId !== itemId)
+  );
+  return replaceNode(detachedTree, itemId, (currentNode) => ({
+    ...currentNode,
+    parentItemId: void 0
+  }));
+}
+function attachNode(tree, itemId, parentItemId, index = Number.POSITIVE_INFINITY) {
+  if (!canAttachNode(tree, itemId, parentItemId)) {
+    return tree;
+  }
+  const attachedTree = updateSiblingIds(
+    tree,
+    parentItemId,
+    (itemIds) => insertItemId(itemIds, itemId, index)
+  );
+  return replaceNode(attachedTree, itemId, (currentNode) => ({
+    ...currentNode,
+    parentItemId
+  }));
+}
+export function insertButtonConfiguratorRootNode(tree, node, index = tree.rootItemIds.length) {
+  if (node.item.type !== "group") {
+    return tree;
+  }
+  return {
+    rootItemIds: insertItemId(tree.rootItemIds, node.itemId, index),
+    nodes: [...tree.nodes, node]
+  };
+}
+export function insertButtonConfiguratorChildNode(tree, parentItemId, node, index = Number.POSITIVE_INFINITY) {
+  if (!canAttachNode({
+    ...tree,
+    nodes: [...tree.nodes, node]
+  }, node.itemId, parentItemId)) {
+    return tree;
+  }
+  return {
+    rootItemIds: tree.rootItemIds,
+    nodes: [
+      ...tree.nodes,
+      {
+        ...node,
+        parentItemId
+      }
+    ].map((currentNode) => currentNode.itemId === parentItemId ? {
+      ...currentNode,
+      childItemIds: insertItemId(currentNode.childItemIds, node.itemId, index)
+    } : currentNode)
+  };
+}
+export function moveButtonConfiguratorNodeToParent(tree, itemId, parentItemId, index = Number.POSITIVE_INFINITY) {
+  if (itemId === parentItemId) {
+    return tree;
+  }
+  if (!canAttachNode(tree, itemId, parentItemId)) {
+    return tree;
+  }
+  const detachedTree = detachNode(tree, itemId);
+  return attachNode(detachedTree, itemId, parentItemId, index);
+}
+export function moveButtonConfiguratorSibling(tree, parentItemId, oldIndex, newIndex) {
+  return updateSiblingIds(tree, parentItemId, (itemIds) => moveItemId(itemIds, oldIndex, newIndex));
+}
+function collectDescendantItemIds(tree, itemId) {
+  const node = getButtonConfiguratorNode(tree, itemId);
+  if (!node) {
+    return [];
+  }
+  return [
+    itemId,
+    ...node.childItemIds.flatMap((childItemId) => collectDescendantItemIds(tree, childItemId))
+  ];
+}
+export function removeButtonConfiguratorSubtree(tree, itemId) {
+  const node = getButtonConfiguratorNode(tree, itemId);
+  if (!node) {
+    return tree;
+  }
+  const removedItemIds = collectDescendantItemIds(tree, itemId);
+  const detachedTree = updateSiblingIds(
+    tree,
+    node.parentItemId,
+    (itemIds) => itemIds.filter((currentItemId) => currentItemId !== itemId)
+  );
+  return {
+    ...detachedTree,
+    nodes: detachedTree.nodes.filter((currentNode) => !removedItemIds.includes(currentNode.itemId))
+  };
+}
+export function materializeButtonConfiguratorTree(tree) {
+  function visitButton(itemId) {
+    const node = getButtonConfiguratorNode(tree, itemId);
+    if (!node || node.item.type !== "button") {
+      return void 0;
+    }
+    const nextButton = {
+      id: node.item.id,
+      title: node.item.title
+    };
+    if (node.item.icon) {
+      nextButton.icon = node.item.icon;
+    }
+    if (node.item.variant === "default" || node.item.variant === "primary" || node.item.variant === "destructive" || node.item.variant === "ghost") {
+      nextButton.variant = node.item.variant;
+    }
+    if (node.item.tooltip) {
+      nextButton.tooltip = node.item.tooltip;
+    }
+    const parentNode = node.parentItemId ? getButtonConfiguratorNode(tree, node.parentItemId) : void 0;
+    if (parentNode?.item.type === "group" && node.item.hideTitle) {
+      nextButton.hideTitle = node.item.hideTitle;
+    }
+    return nextButton;
+  }
+  function visitDropdown(itemId) {
+    const node = getButtonConfiguratorNode(tree, itemId);
+    if (!node || node.item.type !== "dropdown") {
+      return void 0;
+    }
+    const nextDropdown = {
+      id: node.item.id,
+      title: node.item.title,
+      items: node.childItemIds.flatMap((childItemId) => {
+        const button = visitButton(childItemId);
+        return button ? [{
+          id: button.id,
+          title: button.title,
+          tooltip: button.tooltip,
+          icon: button.icon,
+          variant: button.variant
+        }] : [];
+      })
+    };
+    if (node.item.icon) {
+      nextDropdown.icon = node.item.icon;
+    }
+    return nextDropdown;
+  }
+  function visitGroupItem(itemId) {
+    const node = getButtonConfiguratorNode(tree, itemId);
+    if (!node) {
+      return void 0;
+    }
+    if (node.item.type === "dropdown") {
+      return visitDropdown(itemId);
+    }
+    if (node.item.type === "button") {
+      return visitButton(itemId);
+    }
+    return void 0;
+  }
+  function visitGroup(itemId) {
+    const node = getButtonConfiguratorNode(tree, itemId);
+    if (!node || node.item.type !== "group") {
+      return void 0;
+    }
+    return {
+      id: node.item.id,
+      items: node.childItemIds.flatMap((childItemId) => {
+        const item = visitGroupItem(childItemId);
+        return item ? [item] : [];
+      })
+    };
+  }
+  return tree.rootItemIds.flatMap((itemId) => {
+    const group = visitGroup(itemId);
+    return group ? [group] : [];
+  });
+}
+export function isButtonConfiguratorNodeContainer(node) {
+  if (!node) {
+    return false;
+  }
+  return node.item.type === "group" || node.item.type === "dropdown";
+}

package/dist/runtime/components/ui/buttons/Buttons.d.vue.ts

@@ -0,0 +1,95 @@
+import { Effect } from 'effect';
+import { type ButtonConfig } from './schema.js';
+export { ButtonActionC, ButtonConfigC, ButtonConfigInputC, ButtonDropdownC, ButtonGroupC, ButtonsStyleC } from './schema.js';
+export type { ButtonAction, ButtonConfig, ButtonConfigInput, ButtonDropdown, ButtonGroup, ButtonGroupItem } from './schema.js';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
+    config: Effect.Effect<ButtonConfig | import("./schema.js").ButtonConfigInput | undefined>;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:config": (args_0: Readonly<{
+        groups: readonly Readonly<{
+            id: string;
+            items: readonly (Readonly<{
+                id: string;
+                title: readonly {
+                    locale: "zh" | "ja" | "en" | "ko";
+                    message: string;
+                }[];
+                tooltip?: readonly {
+                    locale: "zh" | "ja" | "en" | "ko";
+                    message: string;
+                }[] | undefined;
+                icon?: string | undefined;
+                variant?: "default" | "destructive" | "primary" | "ghost" | undefined;
+                hideTitle?: boolean | undefined;
+            }> | Readonly<{
+                id: string;
+                title: readonly {
+                    locale: "zh" | "ja" | "en" | "ko";
+                    message: string;
+                }[];
+                items: readonly Readonly<{
+                    id: string;
+                    title: readonly {
+                        locale: "zh" | "ja" | "en" | "ko";
+                        message: string;
+                    }[];
+                    tooltip?: readonly {
+                        locale: "zh" | "ja" | "en" | "ko";
+                        message: string;
+                    }[] | undefined;
+                    icon?: string | undefined;
+                    variant?: "default" | "destructive" | "primary" | "ghost" | undefined;
+                }>[];
+                icon?: string | undefined;
+            }>)[];
+        }>[];
+        gap?: number | undefined;
+        style?: string | undefined;
+    }>) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    config: Effect.Effect<ButtonConfig | import("./schema.js").ButtonConfigInput | undefined>;
+}> & Readonly<{
+    "onUpdate:config"?: ((args_0: Readonly<{
+        groups: readonly Readonly<{
+            id: string;
+            items: readonly (Readonly<{
+                id: string;
+                title: readonly {
+                    locale: "zh" | "ja" | "en" | "ko";
+                    message: string;
+                }[];
+                tooltip?: readonly {
+                    locale: "zh" | "ja" | "en" | "ko";
+                    message: string;
+                }[] | undefined;
+                icon?: string | undefined;
+                variant?: "default" | "destructive" | "primary" | "ghost" | undefined;
+                hideTitle?: boolean | undefined;
+            }> | Readonly<{
+                id: string;
+                title: readonly {
+                    locale: "zh" | "ja" | "en" | "ko";
+                    message: string;
+                }[];
+                items: readonly Readonly<{
+                    id: string;
+                    title: readonly {
+                        locale: "zh" | "ja" | "en" | "ko";
+                        message: string;
+                    }[];
+                    tooltip?: readonly {
+                        locale: "zh" | "ja" | "en" | "ko";
+                        message: string;
+                    }[] | undefined;
+                    icon?: string | undefined;
+                    variant?: "default" | "destructive" | "primary" | "ghost" | undefined;
+                }>[];
+                icon?: string | undefined;
+            }>)[];
+        }>[];
+        gap?: number | undefined;
+        style?: string | undefined;
+    }>) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;