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

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");
+    });
+  });
+});

package/core/utilities/date/convertMomentFormat.ts

@@ -0,0 +1,30 @@
+const LOCALE_SHORTCUTS: [string, string][] = [
+  ["LLLL", "PPPp"],
+  ["LLL", "PPp"],
+  ["LTS", "pp"],
+  ["LT", "p"],
+  ["LL", "PP"],
+  ["L", "P"],
+];
+
+const TOKEN_MAP: [RegExp, string][] = [
+  [/YYYY/g, "yyyy"],
+  [/YY/g, "yy"],
+  [/dddd/g, "EEEE"],
+  [/ddd/g, "EEE"],
+  [/DD/g, "dd"],
+  [/Do/g, "do"],
+  [/D(?![\w])/g, "d"],
+  [/A/g, "a"],
+];
+
+export function convertMomentFormat(momentFormat: string): string {
+  let result = momentFormat;
+  for (const [moment, dateFns] of LOCALE_SHORTCUTS) {
+    result = result.split(moment).join(dateFns);
+  }
+  for (const [pattern, replacement] of TOKEN_MAP) {
+    result = result.replace(pattern, replacement);
+  }
+  return result;
+}

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

@@ -0,0 +1,60 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { formatDateRelative, formatDateWithPattern } from "./formatDate";
+
+describe("formatDateRelative", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("returns relative time for a past date", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2024-06-15T12:00:00Z"));
+
+    const pastDate = new Date("2024-06-15T11:00:00Z");
+    const result = formatDateRelative(pastDate);
+    expect(result).toContain("ago");
+  });
+
+  it("handles ISO string input", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2024-06-15T12:00:00Z"));
+
+    const result = formatDateRelative("2024-06-15T11:30:00Z");
+    expect(result).toContain("ago");
+  });
+
+  it('returns "" for null', () => {
+    expect(formatDateRelative(null)).toBe("");
+  });
+
+  it('returns "" for undefined', () => {
+    expect(formatDateRelative(undefined)).toBe("");
+  });
+
+  it('returns "" for empty string', () => {
+    expect(formatDateRelative("")).toBe("");
+  });
+});
+
+describe("formatDateWithPattern", () => {
+  it("formats with 'YYYY-MM-DD HH:mm' pattern", () => {
+    const date = new Date("2024-03-15T14:30:00Z");
+    const result = formatDateWithPattern(date, "YYYY-MM-DD HH:mm");
+    expect(result).toMatch(/2024-03-15 \d{2}:30/);
+  });
+
+  it("formats with 'DD.MM.YYYY' pattern", () => {
+    const date = new Date("2024-03-15T00:00:00Z");
+    const result = formatDateWithPattern(date, "DD.MM.YYYY");
+    expect(result).toMatch(/15\.03\.2024/);
+  });
+
+  it("accepts string date input", () => {
+    const result = formatDateWithPattern("2024-01-01T00:00:00Z", "YYYY-MM-DD");
+    expect(result).toMatch(/2024-01-01/);
+  });
+
+  it('returns "" for null', () => {
+    expect(formatDateWithPattern(null, "YYYY-MM-DD")).toBe("");
+  });
+});

package/core/utilities/date/formatDate.ts

@@ -0,0 +1,31 @@
+import { formatDistanceToNow, format } from "date-fns";
+import { convertMomentFormat } from "./convertMomentFormat";
+import { resolveLocaleSync } from "./resolveLocale";
+
+type DateInput = string | number | Date | null | undefined;
+
+function toDate(value: DateInput): Date | null {
+  if (value == null || value === "") return null;
+  if (value instanceof Date) return value;
+  const d = new Date(value);
+  return isNaN(d.getTime()) ? null : d;
+}
+
+export function formatDateRelative(value: DateInput, localeCode?: string): string {
+  const date = toDate(value);
+  if (!date) return "";
+  const locale = localeCode ? resolveLocaleSync(localeCode) : undefined;
+  return formatDistanceToNow(date, { addSuffix: true, locale });
+}
+
+export function formatDateWithPattern(
+  value: DateInput,
+  momentFormatStr: string,
+  localeCode?: string,
+): string {
+  const date = toDate(value);
+  if (!date) return "";
+  const dateFnsFormat = convertMomentFormat(momentFormatStr);
+  const locale = localeCode ? resolveLocaleSync(localeCode) : undefined;
+  return format(date, dateFnsFormat, { locale });
+}

package/core/utilities/date/index.ts

@@ -0,0 +1,3 @@
+export { formatDateRelative, formatDateWithPattern } from "./formatDate";
+export { convertMomentFormat } from "./convertMomentFormat";
+export { resolveLocale, resolveLocaleSync } from "./resolveLocale";

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

@@ -0,0 +1,44 @@
+import { describe, it, expect } from "vitest";
+import { resolveLocale, resolveLocaleSync } from "./resolveLocale";
+import { enUS } from "date-fns/locale";
+
+describe("resolveLocale", () => {
+  it("returns enUS for 'en-US'", async () => {
+    const locale = await resolveLocale("en-US");
+    expect(locale).toBe(enUS);
+  });
+
+  it("returns enUS for 'en'", async () => {
+    const locale = await resolveLocale("en");
+    expect(locale).toBe(enUS);
+  });
+
+  it("returns enUS as fallback for unknown locale 'xx-XX'", async () => {
+    const locale = await resolveLocale("xx-XX");
+    expect(locale).toBe(enUS);
+  });
+
+  it("returns correct locale for 'de' (dynamic load)", async () => {
+    const locale = await resolveLocale("de");
+    expect(locale).toBeDefined();
+    expect(locale).not.toBe(enUS);
+  });
+
+  it("returns correct locale for 'fr-CA' (compound, dynamic load)", async () => {
+    const locale = await resolveLocale("fr-CA");
+    expect(locale).toBeDefined();
+    expect(locale).not.toBe(enUS);
+  });
+});
+
+describe("resolveLocaleSync", () => {
+  it("returns cached enUS for 'en-US'", () => {
+    const locale = resolveLocaleSync("en-US");
+    expect(locale).toBe(enUS);
+  });
+
+  it("returns enUS fallback for uncached locale", () => {
+    const locale = resolveLocaleSync("zz-ZZ");
+    expect(locale).toBe(enUS);
+  });
+});