@vc-shell/framework 1.2.4-beta.3 → 1.2.4-beta.5

package/core/services/menu-service.test.ts

@@ -115,4 +115,197 @@ describe("menu-service", () => {
     menuServiceBus.dispose(service);
     expect(menuServiceBus.instanceCount).toBe(0);
   });
+
+  describe("identity and deduplication", () => {
+    it("removeMenuItem matches finalized item from menuItems.value against raw storage", async () => {
+      // This is the critical scenario: user gets item from menuItems.value
+      // (which has been through finalizeMenuItems) and passes it to removeMenuItem.
+      // Must work even though finalized item may have extra fields.
+      const { createMenuService } = await loadMenuServiceModule();
+      const service = createMenuService();
+
+      service.addMenuItem({ title: "A", priority: 1, url: "/a" } as any);
+      service.addMenuItem({ title: "B", priority: 2, url: "/b" } as any);
+
+      const firstItem = service.menuItems.value[0];
+      service.removeMenuItem(firstItem);
+
+      expect(service.menuItems.value).toHaveLength(1);
+      expect(service.menuItems.value[0].title).toBe("B");
+    });
+
+    it("removeMenuItem matches by id when both items have explicit id", async () => {
+      const { createMenuService } = await loadMenuServiceModule();
+      const service = createMenuService();
+
+      service.addMenuItem({ title: "A", priority: 1, id: 10, url: "/a" } as any);
+      service.addMenuItem({ title: "B", priority: 2, id: 20, url: "/b" } as any);
+
+      service.removeMenuItem({ id: 10 } as any);
+
+      expect(service.menuItems.value).toHaveLength(1);
+      expect(service.menuItems.value[0].title).toBe("B");
+    });
+
+    it("removeMenuItem matches by url when both items have url (no routeId)", async () => {
+      const { createMenuService } = await loadMenuServiceModule();
+      const service = createMenuService();
+
+      service.addMenuItem({ title: "Orders", priority: 1, url: "/orders" } as any);
+      service.addMenuItem({ title: "Products", priority: 2, url: "/products" } as any);
+
+      service.removeMenuItem({ url: "/orders" } as any);
+
+      expect(service.menuItems.value).toHaveLength(1);
+      expect(service.menuItems.value[0].title).toBe("Products");
+    });
+
+    it("removeMenuItem matches by routeId", async () => {
+      const { createMenuService } = await loadMenuServiceModule();
+      const service = createMenuService();
+
+      service.addMenuItem({ title: "Orders", priority: 1, url: "/orders", routeId: "Orders" } as any);
+      service.addMenuItem({ title: "Products", priority: 2, url: "/products", routeId: "Products" } as any);
+
+      service.removeMenuItem({ routeId: "Orders" } as any);
+
+      expect(service.menuItems.value).toHaveLength(1);
+      expect(service.menuItems.value[0].title).toBe("Products");
+    });
+
+    it("group children with identical routeId+url are deduplicated (last wins)", async () => {
+      const { createMenuService } = await loadMenuServiceModule();
+      const service = createMenuService();
+
+      service.addMenuItem({
+        title: "Users", priority: 1, url: "/users", routeId: "Users",
+        groupConfig: { id: "admin", title: "Admin", icon: "fas fa-shield" },
+      } as any);
+      service.addMenuItem({
+        title: "Users Updated", priority: 1, url: "/users", routeId: "Users",
+        groupConfig: { id: "admin", title: "Admin" },
+      } as any);
+
+      expect(service.menuItems.value).toHaveLength(1);
+      expect(service.menuItems.value[0].children).toHaveLength(1);
+      expect(service.menuItems.value[0].children![0].title).toBe("Users Updated");
+    });
+
+    it("identity is symmetric — determined by highest-priority field on each item independently", async () => {
+      const { createMenuService } = await loadMenuServiceModule();
+      const service = createMenuService();
+
+      service.addMenuItem({ title: "Page", priority: 1, url: "/page", routeId: "PageRoute" } as any);
+
+      // Removing by url alone won't match — stored item's identity is route:PageRoute, not url:/page
+      service.removeMenuItem({ url: "/page" } as any);
+      expect(service.menuItems.value).toHaveLength(1); // still there
+
+      // Removing by routeId matches
+      service.removeMenuItem({ routeId: "PageRoute" } as any);
+      expect(service.menuItems.value).toHaveLength(0);
+    });
+
+    it("finalized items without explicit id have id undefined", async () => {
+      // Documents the auto-id removal. External consumers of menuItems.value
+      // should use routeId/url/title as fallback identifiers.
+      const { createMenuService } = await loadMenuServiceModule();
+      const service = createMenuService();
+
+      service.addMenuItem({ title: "Orders", priority: 1, url: "/orders", routeId: "Orders" } as any);
+
+      const item = service.menuItems.value[0];
+      expect(item.id).toBeUndefined();
+      expect(item.routeId).toBe("Orders");
+      expect(item.url).toBe("/orders");
+      expect(item.title).toBe("Orders");
+    });
+
+    it("groupConfig updates group properties on second registration", async () => {
+      const { createMenuService } = await loadMenuServiceModule();
+      const service = createMenuService();
+
+      service.addMenuItem({
+        title: "Item A", priority: 1, url: "/a", routeId: "A",
+        groupConfig: { id: "grp", title: "Old Title", icon: "old-icon", priority: 10 },
+      } as any);
+      service.addMenuItem({
+        title: "Item B", priority: 2, url: "/b", routeId: "B",
+        groupConfig: { id: "grp", title: "New Title", icon: "new-icon", priority: 5 },
+      } as any);
+
+      const group = service.menuItems.value[0];
+      expect(group.title).toBe("New Title");
+      expect(group.groupIcon).toBe("new-icon");
+      expect(group.priority).toBe(5);
+      expect(group.children).toHaveLength(2);
+    });
+
+    it("standalone items with same routeId but different url are deduplicated (last wins)", async () => {
+      const { createMenuService } = await loadMenuServiceModule();
+      const service = createMenuService();
+
+      service.addMenuItem({ title: "V1", priority: 1, url: "/old-path", routeId: "Orders" } as any);
+      service.addMenuItem({ title: "V2", priority: 2, url: "/new-path", routeId: "Orders" } as any);
+
+      // routeId is highest-priority identity field on both items
+      expect(service.menuItems.value).toHaveLength(1);
+      expect(service.menuItems.value[0].title).toBe("V2");
+      expect(service.menuItems.value[0].url).toBe("/new-path");
+    });
+
+    it("standalone items with same url but different routeId coexist", async () => {
+      const { createMenuService } = await loadMenuServiceModule();
+      const service = createMenuService();
+
+      service.addMenuItem({ title: "PageA", priority: 1, url: "/shared", routeId: "RouteA" } as any);
+      service.addMenuItem({ title: "PageB", priority: 2, url: "/shared", routeId: "RouteB" } as any);
+
+      // routeId is compared before url when both routeId are present
+      expect(service.menuItems.value).toHaveLength(2);
+    });
+  });
+
+  describe("removeRegisteredMenuItem", () => {
+    it("cleans bus store so replay does not resurrect item", async () => {
+      const { addMenuItem, removeRegisteredMenuItem, createMenuService } = await loadMenuServiceModule();
+
+      addMenuItem({ title: "Temp", priority: 1, url: "/temp" } as any);
+      removeRegisteredMenuItem({ url: "/temp" } as any);
+
+      const service = createMenuService();
+      expect(service.menuItems.value).toHaveLength(0);
+    });
+
+    it("propagates removal to live service instances", async () => {
+      const { addMenuItem, removeRegisteredMenuItem, createMenuService } = await loadMenuServiceModule();
+
+      addMenuItem({ title: "Live", priority: 1, url: "/live", routeId: "Live" } as any);
+      const service = createMenuService();
+      expect(service.menuItems.value).toHaveLength(1);
+
+      removeRegisteredMenuItem({ routeId: "Live" } as any);
+      expect(service.menuItems.value).toHaveLength(0);
+    });
+
+    it("removes grouped item from bus store without affecting siblings", async () => {
+      const { addMenuItem, removeRegisteredMenuItem, createMenuService } = await loadMenuServiceModule();
+
+      addMenuItem({
+        title: "Users", priority: 1, url: "/users", routeId: "Users",
+        groupConfig: { id: "admin", title: "Admin", icon: "fas fa-shield" },
+      } as any);
+      addMenuItem({
+        title: "Roles", priority: 2, url: "/roles", routeId: "Roles",
+        groupConfig: { id: "admin", title: "Admin" },
+      } as any);
+
+      removeRegisteredMenuItem({ routeId: "Users" } as any);
+
+      const service = createMenuService();
+      expect(service.menuItems.value).toHaveLength(1);
+      expect(service.menuItems.value[0].children).toHaveLength(1);
+      expect(service.menuItems.value[0].children![0].title).toBe("Roles");
+    });
+  });
 });

package/core/services/menu-service.ts

@@ -1,15 +1,19 @@
-import { Component, ref, type Ref } from "vue";
+import { type Component, ref, type Ref } from "vue";
 import * as _ from "lodash-es";
 import type { MenuItem, MenuItemBadgeConfig } from "@core/types";
-import { createUnrefFn, useArrayFind } from "@vueuse/core";
 import { createPreregistrationBus } from "@core/services/_internal";
 
-function menuItemKey(item: MenuItem): string {
+/**
+ * Canonical identity key for a menu item. Single source of truth.
+ * Priority: id → routeId → url → groupConfig.id+title → group+title → deep hash.
+ * isSameMenuItem is derived from this function.
+ */
+function menuItemIdentity(item: MenuItem): string {
   if (item.id !== undefined) return `id:${String(item.id)}`;
   if (item.routeId) return `route:${item.routeId}`;
   if (item.url) return `url:${item.url}`;
-  if (item.groupConfig?.id && item.title) return `gc:${item.groupConfig.id}:${item.title}`;
-  if (item.group && item.title) return `g:${item.group}:${item.title}`;
+  if (item.groupConfig?.id) return `gc:${item.groupConfig.id}:${item.title}`;
+  if (item.group) return `g:${item.group}:${item.title}`;
   return `hash:${JSON.stringify(_.omit(item, "title"))}`;
 }
 
@@ -18,7 +22,7 @@ const preregisteredMenuBadges: Ref<Map<string, MenuItemBadgeConfig>> = ref(new M
 
 export const menuServiceBus = createPreregistrationBus<MenuItem, MenuService>({
   name: "menu-service",
-  getKey: menuItemKey,
+  getKey: menuItemIdentity,
   registerIntoService: (service, item) => service.addMenuItem(item),
 });
 
@@ -29,6 +33,18 @@ export function addMenuItem(item: MenuItem): void {
   menuServiceBus.preregister(item);
 }
 
+/**
+ * Removes a previously registered menu item from the bus store and all live services.
+ * Works both before and after the service is initialized.
+ *
+ * The caller must provide the same identity fields used during registration
+ * (typically routeId, or url, or explicit id).
+ */
+export function removeRegisteredMenuItem(item: MenuItem): void {
+  menuServiceBus.removePreregistered((stored) => isSameMenuItem(stored, item));
+  menuServiceBus.broadcast((service) => service.removeMenuItem(item));
+}
+
 /**
  * Sets a badge for a menu item by its routeId (blade name) or groupId.
  * Can be called at any time, even after menu registration.
@@ -86,215 +102,148 @@ export interface MenuService {
 const DEFAULT_PRIORITY = Infinity;
 const DEFAULT_GROUP_PRIORITY = Infinity;
 
+/**
+ * Checks if two menu items represent the same logical item.
+ * Derived from menuItemIdentity — single source of truth.
+ *
+ * Note: This is symmetric — both items are compared by their
+ * highest-priority identity field. Passing a partial item (e.g. only url)
+ * will only match items whose highest-priority field is also url.
+ */
 function isSameMenuItem(left: MenuItem, right: MenuItem): boolean {
-  if (left.id !== undefined && right.id !== undefined) {
-    return String(left.id) === String(right.id);
-  }
-
-  if (left.routeId && right.routeId) {
-    return left.routeId === right.routeId;
-  }
+  return menuItemIdentity(left) === menuItemIdentity(right);
+}
 
-  if (left.url && right.url) {
-    return left.url === right.url;
-  }
+interface GroupInfo {
+  groupId: string;
+  groupTitle: string;
+  groupIcon: string | Component | undefined;
+  groupPriority: number | undefined;
+  groupPermissions: string | string[] | undefined;
+}
 
-  if (left.groupConfig?.id && right.groupConfig?.id) {
-    return left.groupConfig.id === right.groupConfig.id && left.title === right.title;
+function extractGroupInfo(item: MenuItem): GroupInfo {
+  if (item.groupConfig) {
+    return {
+      groupId: item.groupConfig.id,
+      groupTitle: item.groupConfig.title || item.groupConfig.id,
+      groupIcon: item.groupConfig.icon,
+      groupPriority: item.groupConfig.priority,
+      groupPermissions: item.groupConfig.permissions,
+    };
   }
+  return {
+    groupId: "group_" + _.snakeCase(item.group as string),
+    groupTitle: item.group as string,
+    groupIcon: item.groupIcon,
+    groupPriority: item.priority,
+    groupPermissions: undefined,
+  };
+}
 
-  if (left.group && right.group) {
-    return left.group === right.group && left.title === right.title;
-  }
+function sortByPriority(a: MenuItem, b: MenuItem): number {
+  return (a.priority ?? DEFAULT_PRIORITY) - (b.priority ?? DEFAULT_PRIORITY);
+}
 
-  return _.isEqual(_.omit(left, "title"), _.omit(right, "title"));
+function sortByGroupPriority(a: MenuItem, b: MenuItem): number {
+  const p = (item: MenuItem): number => item.inGroupPriority ?? item.priority ?? DEFAULT_GROUP_PRIORITY;
+  return p(a) - p(b);
 }
 
 /**
- * Menu service implementation
- * Handles the registration and organization of menu items
+ * Adds a raw item into the groups map. Creates or updates the group immutably.
  */
-export function createMenuService(): MenuService {
-  const menuItems: Ref<MenuItem[]> = ref([]);
-  const rawMenu: Ref<MenuItem[]> = ref([]);
-  const menuBadges: Ref<Map<string, MenuItemBadgeConfig>> = ref(new Map(preregisteredMenuBadges.value));
+function addItemToGroup(item: MenuItem, groups: Map<string, MenuItem>): void {
+  const info = extractGroupInfo(item);
 
-  /**
-   * Add a new menu item to the raw menu and rebuild the menu structure
-   * @param item - The menu item to add
-   */
-  function addMenuItem(item: MenuItem): void {
-    rawMenu.value.push(item);
-    constructMenu();
-  }
+  const groupItem = {
+    ..._.omit(item, ["group", "groupIcon", "groupPriority", "groupConfig"]),
+  } as MenuItem;
 
-  /**
-   * Removes a menu item from the menu
-   * @param item - The menu item to remove
-   */
-  function removeMenuItem(item: MenuItem): void {
-    const initialLength = rawMenu.value.length;
-    rawMenu.value = rawMenu.value.filter((existingItem) => !isSameMenuItem(existingItem, item));
+  const existing = groups.get(info.groupId);
 
-    if (rawMenu.value.length !== initialLength) {
-      constructMenu();
+  if (existing) {
+    const children = [...(existing.children ?? [])];
+    const childIndex = children.findIndex((c) => isSameMenuItem(c, groupItem));
+    if (childIndex > -1) {
+      children[childIndex] = groupItem;
+    } else {
+      children.push(groupItem);
     }
-  }
-
-  /**
-   * Updates an element in an array or adds it if not found
-   */
-  const upsert = createUnrefFn(
-    (array: (MenuItem | Omit<MenuItem, "icon">)[], element: MenuItem | Omit<MenuItem, "icon">) => {
-      const index = array.findIndex((_element) => _.isEqual(_.omit(_element, "title"), _.omit(element, "title")));
-      if (index > -1) {
-        array[index] = { ...element };
-      } else {
-        array.push({ ...element });
-      }
-    },
-  );
-
-  /**
-   * Sorts menu items by their priority
-   */
-  function sortByPriority(a: MenuItem, b: MenuItem): number {
-    const getPriority = (item: MenuItem): number => item.priority ?? DEFAULT_PRIORITY;
-    return getPriority(a) - getPriority(b);
-  }
-
-  /**
-   * Sorts items within a group by their inGroupPriority / priority
-   */
-  function sortByGroupPriority(a: MenuItem, b: MenuItem): number {
-    const getGroupPriority = (item: MenuItem): number =>
-      item.inGroupPriority ?? item.priority ?? DEFAULT_GROUP_PRIORITY;
-    return getGroupPriority(a) - getGroupPriority(b);
-  }
 
-  /**
-   * Creates a localized ID from a title
-   */
-  function createItemId(title: string): string {
-    return _.snakeCase(title);
+    // Immutable group update
+    groups.set(info.groupId, {
+      ...existing,
+      children,
+      ...(item.groupConfig?.title && { title: item.groupConfig.title }),
+      ...(item.groupConfig?.icon !== undefined && { groupIcon: item.groupConfig.icon }),
+      ...(item.groupConfig?.priority !== undefined && { priority: item.groupConfig.priority }),
+      ...(item.groupConfig?.permissions !== undefined && { permissions: item.groupConfig.permissions }),
+    });
+  } else {
+    groups.set(info.groupId, {
+      groupId: info.groupId,
+      groupIcon: info.groupIcon ?? "",
+      title: info.groupTitle,
+      children: [groupItem],
+      priority: info.groupPriority ?? item.priority ?? DEFAULT_PRIORITY,
+      permissions: info.groupPermissions,
+    } as MenuItem);
   }
+}
 
-  /**
-   * Processes a menu item that belongs to a group
-   */
-  function processGroupItem(item: MenuItem, constructedMenu: Ref<MenuItem[]>): void {
-    // Skip if no group information provided
-    if (!item.group && !item.groupConfig) return;
-
-    let groupId: string;
-    let groupTitle: string;
-    let groupIcon: string | Component | undefined;
-    let groupPriority: number | undefined;
-    let groupPermissions: string | string[] | undefined;
-
-    // Prefer groupConfig over legacy group properties
-    if (item.groupConfig) {
-      // Use the explicit group ID from groupConfig
-      groupId = item.groupConfig.id;
-      groupTitle = item.groupConfig.title || groupId;
-      groupIcon = item.groupConfig.icon;
-      groupPriority = item.groupConfig.priority;
-      groupPermissions = item.groupConfig.permissions;
-    } else {
-      // Fallback to legacy group properties
-      groupId = "group_" + createItemId(item.group as string);
-      groupTitle = item.group as string;
-      groupIcon = item.groupIcon;
-      groupPriority = item.priority; // Use item priority as group priority for legacy
-    }
-
-    const existingGroup = useArrayFind(constructedMenu, (m) => m.groupId === groupId);
-
-    // Create the item to be added to the group
-    const groupItem = {
-      ..._.omit(item, ["group", "groupIcon", "groupPriority", "groupConfig"]),
-      title: item.title,
-    } as MenuItem;
-
-    if (existingGroup.value && existingGroup.value.children) {
-      // Add to existing group
-      upsert(existingGroup.value.children, groupItem);
-
-      // Update existing group properties if using groupConfig
-      if (item.groupConfig) {
-        if (item.groupConfig.title) {
-          existingGroup.value.title = item.groupConfig.title;
-        }
-        if (item.groupConfig.icon !== undefined) {
-          existingGroup.value.groupIcon = item.groupConfig.icon;
-        }
-        if (item.groupConfig.priority !== undefined) {
-          existingGroup.value.priority = item.groupConfig.priority;
-        }
-        if (item.groupConfig.permissions !== undefined) {
-          existingGroup.value.permissions = item.groupConfig.permissions;
-        }
-      }
-    } else {
-      // Create a new group with this item
-      const group = {
-        groupId,
-        groupIcon: groupIcon ?? "",
-        title: groupTitle,
-        children: [groupItem],
-        priority: groupPriority ?? item.priority ?? DEFAULT_PRIORITY,
-        permissions: groupPermissions,
-      } as MenuItem;
-      upsert(constructedMenu.value, group);
+/**
+ * Builds the finalized menu tree from raw items. Pure function — no side effects.
+ *
+ * Internally uses Maps for dedup (groups by groupId, standalone by identity key).
+ * When duplicate items exist in the input, last registration wins.
+ */
+function buildMenuTree(rawItems: MenuItem[]): MenuItem[] {
+  const groups = new Map<string, MenuItem>();
+  const standalone = new Map<string, MenuItem>();
+
+  for (const item of rawItems) {
+    if (item.group || item.groupConfig) {
+      addItemToGroup(item, groups);
+    } else if (item.title) {
+      standalone.set(menuItemIdentity(item), { ...item });
     }
   }
 
-  /**
-   * Processes a standalone menu item (not in a group)
-   */
-  function processStandaloneItem(item: MenuItem, constructedMenu: Ref<MenuItem[]>): void {
-    if (item.title) {
-      const standaloneItem = {
+  return finalizeMenuItems([...groups.values(), ...standalone.values()]);
+}
+
+function finalizeMenuItems(items: MenuItem[]): MenuItem[] {
+  return items
+    .map(
+      (item): MenuItem => ({
         ...item,
-        title: item.title,
-      } as MenuItem;
-      upsert(constructedMenu.value, standaloneItem);
-    }
-  }
+        children: item.children ? [...item.children].sort(sortByGroupPriority) : undefined,
+      }),
+    )
+    .sort(sortByPriority);
+}
 
-  /**
-   * Finalizes menu items by adding IDs and sorting children
-   */
-  function finalizeMenuItems(items: MenuItem[]): MenuItem[] {
-    return items
-      .map(
-        (item): MenuItem => ({
-          ...item,
-          title: item.title,
-          id: item.id || createItemId(item.title),
-          children: item.children?.sort(sortByGroupPriority),
-        }),
-      )
-      .sort(sortByPriority);
-  }
+/**
+ * Menu service implementation
+ * Handles the registration and organization of menu items
+ */
+export function createMenuService(): MenuService {
+  const menuItems: Ref<MenuItem[]> = ref([]);
+  let rawMenu: MenuItem[] = [];
+  const menuBadges: Ref<Map<string, MenuItemBadgeConfig>> = ref(new Map(preregisteredMenuBadges.value));
 
-  /**
-   * Constructs the complete menu structure from raw menu items
-   */
-  function constructMenu(): void {
-    const constructedMenu: Ref<MenuItem[]> = ref([]);
-
-    // Process each raw menu item
-    rawMenu.value.forEach((item) => {
-      if (item.group || item.groupConfig) {
-        processGroupItem(item, constructedMenu);
-      } else {
-        processStandaloneItem(item, constructedMenu);
-      }
-    });
+  function addMenuItem(item: MenuItem): void {
+    rawMenu.push(item);
+    menuItems.value = buildMenuTree(rawMenu);
+  }
 
-    // Finalize and set the menu items
-    menuItems.value = finalizeMenuItems(constructedMenu.value);
+  function removeMenuItem(item: MenuItem): void {
+    const before = rawMenu.length;
+    rawMenu = rawMenu.filter((raw) => !isSameMenuItem(raw, item));
+    if (rawMenu.length !== before) {
+      menuItems.value = buildMenuTree(rawMenu);
+    }
   }
 
   const service: MenuService = {

package/core/services/toolbar-service.ts

@@ -1,4 +1,4 @@
-import { IBladeToolbar } from "@core/types";
+import type { IBladeToolbar } from "@core/types";
 import { createBladeScopedRegistry, createPreregistrationBus } from "@core/services/_internal";
 
 export interface IToolbarItem extends IBladeToolbar {

package/core/services/widget-service.ts

@@ -1,5 +1,5 @@
 import { Component, ref, ComponentInternalInstance, ComputedRef, Ref } from "vue";
-import { IBladeInstance } from "@shared/components/blade-navigation/types";
+import type { IBladeInstance } from "@shared/components/blade-navigation/types";
 import { cloneDeep } from "lodash-es";
 import { createBladeScopedRegistry, createPreregistrationBus } from "@core/services/_internal";
 import { createLogger } from "@core/utilities";

package/core/types/index.ts

@@ -1,7 +1,7 @@
 import { Component, ComputedRef, Ref } from "vue";
-import { CoreBladeExposed } from "@shared";
-import { ComponentPublicInstanceConstructor } from "@shared/utilities";
-import { IBladeInstance } from "@shared/components/blade-navigation/types";
+import type { CoreBladeExposed } from "@shared/components/blade-navigation/types";
+import type { ComponentPublicInstanceConstructor } from "@shared/utilities/vueUtils";
+import type { IBladeInstance } from "@shared/components/blade-navigation/types";
 
 // AI Agent types are now part of the ai-agent plugin
 // export * from "./plugins/ai-agent/types";

package/core/utilities/date/convertMomentFormat.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect } from "vitest";
+import { convertMomentFormat } from "./convertMomentFormat";
+
+describe("convertMomentFormat", () => {
+  describe("locale shortcuts", () => {
+    it("converts L to P", () => {
+      expect(convertMomentFormat("L")).toBe("P");
+    });
+
+    it("converts LT to p", () => {
+      expect(convertMomentFormat("LT")).toBe("p");
+    });
+
+    it("converts LTS to pp", () => {
+      expect(convertMomentFormat("LTS")).toBe("pp");
+    });
+
+    it("converts LL to PP", () => {
+      expect(convertMomentFormat("LL")).toBe("PP");
+    });
+
+    it("converts LLL to PPp", () => {
+      expect(convertMomentFormat("LLL")).toBe("PPp");
+    });
+
+    it("converts LLLL to PPPp", () => {
+      expect(convertMomentFormat("LLLL")).toBe("PPPp");
+    });
+
+    it("converts combined 'L LT' to 'P p'", () => {
+      expect(convertMomentFormat("L LT")).toBe("P p");
+    });
+  });
+
+  describe("token conversions", () => {
+    it("converts 'YYYY-MM-DD' to 'yyyy-MM-dd'", () => {
+      expect(convertMomentFormat("YYYY-MM-DD")).toBe("yyyy-MM-dd");
+    });
+
+    it("converts 'DD.MM.YYYY HH:mm' to 'dd.MM.yyyy HH:mm'", () => {
+      expect(convertMomentFormat("DD.MM.YYYY HH:mm")).toBe("dd.MM.yyyy HH:mm");
+    });
+
+    it("converts 'DD/MM/YY' to 'dd/MM/yy'", () => {
+      expect(convertMomentFormat("DD/MM/YY")).toBe("dd/MM/yy");
+    });
+
+    it("converts 'ddd, MMM Do YYYY' to 'EEE, MMM do yyyy'", () => {
+      expect(convertMomentFormat("ddd, MMM Do YYYY")).toBe("EEE, MMM do yyyy");
+    });
+
+    it("converts 'dddd' to 'EEEE'", () => {
+      expect(convertMomentFormat("dddd")).toBe("EEEE");
+    });
+
+    it("converts 'hh:mm A' to 'hh:mm a'", () => {
+      expect(convertMomentFormat("hh:mm A")).toBe("hh:mm a");
+    });
+  });
+});