@spteck/react-controls-v2 2.0.18 → 2.2.1

package/dist/LocalizationProvider-BSlUf0tp.js

@@ -0,0 +1,497 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useEffect, useCallback } from "react";
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["Verbose"] = 0] = "Verbose";
+  LogLevel2[LogLevel2["Info"] = 1] = "Info";
+  LogLevel2[LogLevel2["Warning"] = 2] = "Warning";
+  LogLevel2[LogLevel2["Error"] = 3] = "Error";
+  return LogLevel2;
+})(LogLevel || {});
+var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+  ErrorType2["Error"] = "Error";
+  ErrorType2["Warning"] = "Warning";
+  ErrorType2["Info"] = "Info";
+  return ErrorType2;
+})(ErrorType || {});
+const en = {
+  common: {
+    loading: "Loading...",
+    error: "Error",
+    noData: "No data",
+    close: "Close",
+    save: "Save",
+    cancel: "Cancel",
+    ok: "OK",
+    searchPlaceholder: "Search..."
+  },
+  kpi: {
+    noDescription: "No description available",
+    defaultTitle: "KPI",
+    lowerIsBetter: "Lower is better",
+    higherIsBetter: "Higher is better",
+    withinGoalThreshold: "Within goal threshold",
+    exceedsGoalThreshold: "Exceeds goal threshold",
+    goal: "Goal",
+    progressGoal: "Progress to goal",
+    maxAllowedThreshold: "Max allowed threshold",
+    totalItemsInScope: "Total items in scope",
+    totalItems: "Total",
+    currentValueAsPercent: "Current value as percentage of total",
+    percentOfTotal: "%",
+    onTrack: "On Track",
+    exceedGoal: "Exceeds Goal"
+  },
+  noKpis: {
+    title: "No KPIs Configured",
+    subtitle: "Start tracking your team's performance by configuring {highlight} in the App Configuration list.",
+    highlightText: "KPI parameters",
+    configureButton: "Configure KPIs"
+  },
+  calendar: {
+    calendarControl: {
+      daysOfWeek: [
+        "Sunday",
+        "Monday",
+        "Tuesday",
+        "Wednesday",
+        "Thursday",
+        "Friday",
+        "Saturday"
+      ]
+    },
+    selectCalendarView: {
+      month: "Month",
+      week: "Week",
+      day: "Day"
+    },
+    eventPopoverCard: {
+      timeSeparator: " - ",
+      hourSuffix: "h"
+    },
+    eventDetailsPopover: {
+      start: "Start",
+      end: "End",
+      location: "Location",
+      attendees: "Attendees",
+      details: "Details"
+    },
+    dayView: {
+      allDay: "All Day"
+    },
+    toolbar: {
+      today: "Today",
+      previous: "Previous",
+      next: "Next"
+    },
+    weekView: {
+      allDay: "All Day"
+    },
+    calendarMonth: {
+      months: [
+        "January",
+        "February",
+        "March",
+        "April",
+        "May",
+        "June",
+        "July",
+        "August",
+        "September",
+        "October",
+        "November",
+        "December"
+      ],
+      shortMonths: [
+        "Jan",
+        "Feb",
+        "Mar",
+        "Apr",
+        "May",
+        "Jun",
+        "Jul",
+        "Aug",
+        "Sep",
+        "Oct",
+        "Nov",
+        "Dec"
+      ],
+      days: [
+        "Sunday",
+        "Monday",
+        "Tuesday",
+        "Wednesday",
+        "Thursday",
+        "Friday",
+        "Saturday"
+      ],
+      shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+      goToToday: "Go to today"
+    },
+    selectWeek: {
+      selectWeekPlaceholder: "Select a Week"
+    }
+  },
+  mensions: {
+    placeholder: "Type a message...",
+    noResults: "No results found",
+    send: "Send"
+  },
+  shareDialog: {
+    title: "Share",
+    copyLink: "Copy link",
+    linkCopied: "Link copied!",
+    share: "Share",
+    cancel: "Cancel"
+  },
+  userCard: {
+    available: "Available",
+    availableIdle: "Available, idle",
+    away: "Away",
+    busy: "Busy",
+    busyIdle: "Busy, idle",
+    doNotDisturb: "Do not disturb",
+    beRightBack: "Be right back",
+    appearOffline: "Appear offline",
+    unknown: "Unknown",
+    outOfOffice: "Out of office",
+    offline: "Offline",
+    userAvatar: "User Avatar",
+    unknownUser: "Unknown User"
+  },
+  appDashboard: {
+    noDashboardsAvailable: "No Dashboards Available",
+    clickToSetSpan: "Click to set span",
+    configure: "Configure"
+  },
+  aiAssistant: {
+    processingError: "There was an error processing your request.",
+    noUsersFound: "No users found",
+    typeAMessage: "Type a message"
+  },
+  worldMap: {
+    loadingMapStyle: "Loading map style…",
+    coordinates: "Coordinates:",
+    zoomIn: "Zoom in",
+    zoomOut: "Zoom out",
+    resetMap: "Reset map",
+    reset: "Reset"
+  },
+  aiSearchControl: {
+    placeholder: "Ask AI to generate search query... (e.g., 'Find engineers in the Seattle office')",
+    notConfiguredError: "Azure OpenAI is not properly configured. Please check your configuration.",
+    generationError: "An error occurred during AI search query generation"
+  },
+  itemPicker: {
+    placeholder: "Search…",
+    noResultsFound: "No results found",
+    searching: "Searching…",
+    loadingMore: "Loading more…",
+    selectedItems: "Selected items",
+    searchItems: "Search items"
+  },
+  listItemActivity: {
+    you: "You",
+    accessed: "accessed this",
+    commented: "commented on this",
+    created: "created this",
+    deleted: "deleted this",
+    edited: "edited this",
+    mentioned: "mentioned you in this",
+    moved: "moved this",
+    renamed: "renamed this",
+    restored: "restored this",
+    shared: "shared this",
+    versioned: "versioned this"
+  },
+  inputField: {
+    fieldRequired: "This field is required",
+    numberRequired: "A number is required",
+    invalidNumber: "Please enter a valid number",
+    valueMustBeAtLeast: "Value must be at least {0}",
+    valueMustBeAtMost: "Value must be at most {0}"
+  },
+  searchControl: {
+    placeholder: "Search…"
+  },
+  mermaidDiagram: {
+    loading: "Loading diagram…",
+    errorTitle: "Diagram Error",
+    errorMessage: "An error occurred while rendering the diagram.",
+    noSource: "No diagram source provided"
+  }
+};
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = target[key];
+    if (sourceVal !== null && sourceVal !== void 0 && typeof sourceVal === "object" && !Array.isArray(sourceVal) && typeof targetVal === "object" && !Array.isArray(targetVal) && targetVal !== null) {
+      result[key] = deepMerge(targetVal, sourceVal);
+    } else if (sourceVal !== void 0) {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+const localeLoaders = {
+  ar: () => import("./ar-C1pLt8fa.js").then((m) => m.ar),
+  az: () => import("./az-C3-F9ybX.js").then((m) => m.az),
+  bg: () => import("./bg-w2e_udiK.js").then((m) => m.bg),
+  bs: () => import("./bs-CEe_gjEx.js").then((m) => m.bs),
+  ca: () => import("./ca-CKpd72XI.js").then((m) => m.ca),
+  cs: () => import("./cs-DQvRPciB.js").then((m) => m.cs),
+  cy: () => import("./cy-BxyJCM05.js").then((m) => m.cy),
+  da: () => import("./da-B05ad5Iq.js").then((m) => m.da),
+  de: () => import("./de-DJ5iwpd7.js").then((m) => m.de),
+  el: () => import("./el-CBS9mHS3.js").then((m) => m.el),
+  es: () => import("./es-Bo08apQr.js").then((m) => m.es),
+  et: () => import("./et-pRL0Tmle.js").then((m) => m.et),
+  eu: () => import("./eu-Br68gaf7.js").then((m) => m.eu),
+  fi: () => import("./fi-BCXB-k_X.js").then((m) => m.fi),
+  fr: () => import("./fr-gKE1SSIF.js").then((m) => m.fr),
+  ga: () => import("./ga-C1SpITZy.js").then((m) => m.ga),
+  gl: () => import("./gl-CSzCeu2L.js").then((m) => m.gl),
+  he: () => import("./he-BrkfqoIm.js").then((m) => m.he),
+  hi: () => import("./hi-C1RGDPzn.js").then((m) => m.hi),
+  hr: () => import("./hr-CsO_h2VT.js").then((m) => m.hr),
+  hu: () => import("./hu-CVtbM-V2.js").then((m) => m.hu),
+  id: () => import("./id-CARSN0W8.js").then((m) => m.id),
+  it: () => import("./it-ClWGK7XT.js").then((m) => m.it),
+  ja: () => import("./ja-DGL12HwE.js").then((m) => m.ja),
+  kk: () => import("./kk-CkKXbKso.js").then((m) => m.kk),
+  ko: () => import("./ko-QYvDV2aw.js").then((m) => m.ko),
+  lt: () => import("./lt-BKnFyiLV.js").then((m) => m.lt),
+  lv: () => import("./lv-Clqo0Ogm.js").then((m) => m.lv),
+  mk: () => import("./mk-EhcD0RzW.js").then((m) => m.mk),
+  ms: () => import("./ms-CJACwjo7.js").then((m) => m.ms),
+  nb: () => import("./nb-NCgnP0Pu.js").then((m) => m.nb),
+  nl: () => import("./nl-EgsNCunP.js").then((m) => m.nl),
+  pl: () => import("./pl-H28GVtiG.js").then((m) => m.pl),
+  pt: () => import("./pt-BSPZhWKl.js").then((m) => m.pt),
+  ro: () => import("./ro-BpaZLre_.js").then((m) => m.ro),
+  ru: () => import("./ru-CUZzD-Tx.js").then((m) => m.ru),
+  sk: () => import("./sk-CoQ6XiCY.js").then((m) => m.sk),
+  sl: () => import("./sl-CHW-ZGol.js").then((m) => m.sl),
+  sr: () => import("./sr-EQGjIBJE.js").then((m) => m.sr),
+  sv: () => import("./sv-DTxWN6ED.js").then((m) => m.sv),
+  th: () => import("./th-BVPzHvBf.js").then((m) => m.th),
+  tr: () => import("./tr-BHR1QA-D.js").then((m) => m.tr),
+  uk: () => import("./uk-Bc5TwelE.js").then((m) => m.uk),
+  vi: () => import("./vi-DC0eQZb7.js").then((m) => m.vi),
+  zh: () => import("./zh-GsCLn8OE.js").then((m) => m.zh)
+};
+const RTL_LOCALES = /* @__PURE__ */ new Set(["ar", "he", "fa", "ur"]);
+class DefaultLocalizationProvider {
+  constructor(locale) {
+    __publicField(this, "_locale");
+    __publicField(this, "_isRtl");
+    __publicField(this, "_loadedBundles");
+    __publicField(this, "_overrides");
+    this._locale = locale || DefaultLocalizationProvider.detectLocale();
+    this._isRtl = DefaultLocalizationProvider.isRtlLocale(this._locale);
+    this._loadedBundles = /* @__PURE__ */ new Map();
+    this._loadedBundles.set("en", en);
+    this._overrides = {};
+  }
+  // ─── ILocalizationProvider implementation ─────────────────────
+  get locale() {
+    return this._locale;
+  }
+  get isRtl() {
+    return this._isRtl;
+  }
+  getStrings() {
+    const langKey = this.getLanguageKey(this._locale);
+    const bundle = this._loadedBundles.get(langKey) || en;
+    if (langKey === "en" && Object.keys(this._overrides).length === 0) {
+      return en;
+    }
+    let result = en;
+    if (langKey !== "en") {
+      result = deepMerge(en, bundle);
+    }
+    if (Object.keys(this._overrides).length > 0) {
+      result = deepMerge(result, this._overrides);
+    }
+    return result;
+  }
+  getComponentStrings(namespace) {
+    return this.getStrings()[namespace];
+  }
+  async loadBundle(locale) {
+    const langKey = this.getLanguageKey(locale);
+    if (langKey === "en") return;
+    if (this._loadedBundles.has(langKey)) return;
+    const loader = localeLoaders[langKey];
+    if (loader) {
+      try {
+        const bundle = await loader();
+        this._loadedBundles.set(langKey, bundle);
+      } catch (error) {
+        console.warn(
+          `[DefaultLocalizationProvider] Failed to load bundle for locale "${langKey}". Falling back to English.`,
+          error
+        );
+      }
+    } else {
+      console.warn(
+        `[DefaultLocalizationProvider] No bundle available for locale "${langKey}". Using English.`
+      );
+    }
+  }
+  setOverrides(overrides) {
+    this._overrides = overrides;
+  }
+  async setLocale(locale) {
+    this._locale = locale;
+    this._isRtl = DefaultLocalizationProvider.isRtlLocale(locale);
+    await this.loadBundle(locale);
+  }
+  // ─── Static helpers ───────────────────────────────────────────
+  /**
+   * Auto-detect locale from the browser environment
+   * Priority: navigator.language → 'en'
+   */
+  static detectLocale() {
+    if (typeof navigator !== "undefined" && navigator.language) {
+      return navigator.language;
+    }
+    return "en";
+  }
+  /**
+   * Detect locale from SPFx ICultureInfo
+   * Priority: cultureInfo.currentUICultureName → cultureInfo.currentCultureName → detectLocale()
+   */
+  static detectLocaleFromCulture(cultureInfo) {
+    if (cultureInfo == null ? void 0 : cultureInfo.currentUICultureName) return cultureInfo.currentUICultureName;
+    if (cultureInfo == null ? void 0 : cultureInfo.currentCultureName) return cultureInfo.currentCultureName;
+    return DefaultLocalizationProvider.detectLocale();
+  }
+  /**
+   * Check if a locale is RTL
+   */
+  static isRtlLocale(locale) {
+    const langKey = locale.split("-")[0].toLowerCase();
+    return RTL_LOCALES.has(langKey);
+  }
+  // ─── Private helpers ──────────────────────────────────────────
+  /**
+   * Extract the base language key from a locale string (e.g., 'pt-BR' → 'pt')
+   */
+  getLanguageKey(locale) {
+    return locale.split("-")[0].toLowerCase();
+  }
+}
+const LocalizationContext = createContext(void 0);
+const useLocalization = () => {
+  return useContext(LocalizationContext);
+};
+const useStrings = () => {
+  const ctx = useContext(LocalizationContext);
+  return (ctx == null ? void 0 : ctx.strings) ?? en;
+};
+function useComponentStrings(namespace) {
+  const strings = useStrings();
+  return strings[namespace];
+}
+const useKpiStrings = () => useComponentStrings("kpi");
+const useNoKpiStrings = () => useComponentStrings("noKpis");
+const useCalendarStrings = () => useComponentStrings("calendar");
+const useMensionsStrings = () => useComponentStrings("mensions");
+const useShareDialogStrings = () => useComponentStrings("shareDialog");
+const useCommonStrings = () => useComponentStrings("common");
+const useUserCardStrings = () => useComponentStrings("userCard");
+const useAppDashboardStrings = () => useComponentStrings("appDashboard");
+const useAIAssistantStrings = () => useComponentStrings("aiAssistant");
+const useWorldMapStrings = () => useComponentStrings("worldMap");
+const useAISearchControlStrings = () => useComponentStrings("aiSearchControl");
+const useItemPickerStrings = () => useComponentStrings("itemPicker");
+const useListItemActivityStrings = () => useComponentStrings("listItemActivity");
+const useInputFieldStrings = () => useComponentStrings("inputField");
+const useSearchControlStrings = () => useComponentStrings("searchControl");
+const useMermaidDiagramStrings = () => useComponentStrings("mermaidDiagram");
+const LocalizationProvider = ({
+  provider: externalProvider,
+  locale: initialLocale,
+  overrides,
+  children
+}) => {
+  const [provider] = useState(
+    () => externalProvider || new DefaultLocalizationProvider(initialLocale)
+  );
+  const [strings, setStrings] = useState(() => {
+    if (overrides) {
+      provider.setOverrides(overrides);
+    }
+    return provider.getStrings();
+  });
+  const [locale, setLocaleState] = useState(provider.locale);
+  const [isRtl, setIsRtl] = useState(provider.isRtl);
+  useEffect(() => {
+    let cancelled = false;
+    const init = async () => {
+      await provider.loadBundle(provider.locale);
+      if (!cancelled) {
+        setStrings(provider.getStrings());
+      }
+    };
+    init();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  useEffect(() => {
+    if (overrides) {
+      provider.setOverrides(overrides);
+      setStrings(provider.getStrings());
+    }
+  }, [overrides]);
+  const setLocale = useCallback(
+    async (newLocale) => {
+      await provider.setLocale(newLocale);
+      setLocaleState(provider.locale);
+      setIsRtl(provider.isRtl);
+      setStrings(provider.getStrings());
+    },
+    [provider]
+  );
+  const contextValue = {
+    provider,
+    strings,
+    locale,
+    isRtl,
+    setLocale
+  };
+  return /* @__PURE__ */ jsx(LocalizationContext.Provider, { value: contextValue, children });
+};
+export {
+  DefaultLocalizationProvider as D,
+  ErrorType as E,
+  LogLevel as L,
+  LocalizationProvider as a,
+  useSearchControlStrings as b,
+  useItemPickerStrings as c,
+  useWorldMapStrings as d,
+  useAISearchControlStrings as e,
+  useAIAssistantStrings as f,
+  useMensionsStrings as g,
+  useUserCardStrings as h,
+  useMermaidDiagramStrings as i,
+  useListItemActivityStrings as j,
+  useAppDashboardStrings as k,
+  useKpiStrings as l,
+  useNoKpiStrings as m,
+  en as n,
+  useLocalization as o,
+  useStrings as p,
+  useComponentStrings as q,
+  useCalendarStrings as r,
+  useShareDialogStrings as s,
+  useCommonStrings as t,
+  useInputFieldStrings as u,
+  deepMerge as v
+};
+//# sourceMappingURL=LocalizationProvider-BSlUf0tp.js.map

package/dist/_arrayEach-CnIMt1eB.js

@@ -0,0 +1,61 @@
+import { aD as isArray, aE as arrayLikeKeys, aF as baseKeys, aG as isArrayLike } from "./index-CP55uT1-.js";
+function arrayPush(array, values) {
+  var index = -1, length = values.length, offset = array.length;
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+}
+function arrayFilter(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+function stubArray() {
+  return [];
+}
+var objectProto = Object.prototype;
+var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable.call(object, symbol);
+  });
+};
+function keys(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+function getAllKeys(object) {
+  return baseGetAllKeys(object, keys, getSymbols);
+}
+function arrayEach(array, iteratee) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (iteratee(array[index], index, array) === false) {
+      break;
+    }
+  }
+  return array;
+}
+export {
+  getAllKeys as a,
+  arrayEach as b,
+  arrayFilter as c,
+  arrayPush as d,
+  getSymbols as g,
+  keys as k
+};
+//# sourceMappingURL=_arrayEach-CnIMt1eB.js.map

package/dist/_arrayEach-vx8gLv03.cjs

@@ -0,0 +1,2 @@
+"use strict";const r=require("./index-DkoeCnje.cjs");function e(r,e){for(var t=-1,n=e.length,o=r.length;++t<n;)r[o+t]=e[t];return r}function t(r,e){for(var t=-1,n=null==r?0:r.length,o=0,u=[];++t<n;){var s=r[t];e(s,t,r)&&(u[o++]=s)}return u}var n=Object.prototype.propertyIsEnumerable,o=Object.getOwnPropertySymbols,u=o?function(r){return null==r?[]:(r=Object(r),t(o(r),function(e){return n.call(r,e)}))}:function(){return[]};function s(e){return r.isArrayLike(e)?r.arrayLikeKeys(e):r.baseKeys(e)}exports.arrayEach=function(r,e){for(var t=-1,n=null==r?0:r.length;++t<n&&!1!==e(r[t],t,r););return r},exports.arrayFilter=t,exports.arrayPush=e,exports.getAllKeys=function(t){return function(t,n,o){var u=n(t);return r.isArray(t)?u:e(u,o(t))}(t,s,u)},exports.getSymbols=u,exports.keys=s;
+//# sourceMappingURL=_arrayEach-vx8gLv03.cjs.map

package/dist/abstractions/ILocalizationProvider.d.ts

@@ -0,0 +1,52 @@
+import { ILibraryStrings } from '../localization/ILibraryStrings';
+
+/**
+ * Supported locale codes
+ * Can be extended with additional locales
+ */
+export type SupportedLocale = 'en' | 'pt' | 'es' | 'fr' | 'de' | string;
+/**
+ * Interface for the localization provider abstraction
+ * Follows the same pattern as ILoggingProvider, IStorageProvider, etc.
+ */
+export interface ILocalizationProvider {
+    /**
+     * The current locale code (e.g., 'en', 'pt', 'es')
+     */
+    readonly locale: string;
+    /**
+     * Whether the current locale is right-to-left
+     */
+    readonly isRtl: boolean;
+    /**
+     * Get all strings for the current locale
+     * Returns a merged result: defaults ← language bundle ← overrides
+     */
+    getStrings(): ILibraryStrings;
+    /**
+     * Get strings for a specific component namespace
+     * @param namespace - The component namespace (e.g., 'kpi', 'calendar')
+     */
+    getComponentStrings<K extends keyof ILibraryStrings>(namespace: K): ILibraryStrings[K];
+    /**
+     * Load a language bundle for the specified locale
+     * English is always available synchronously; other locales are loaded via dynamic import
+     * @param locale - The locale code to load
+     * @returns A promise that resolves when the bundle is loaded
+     */
+    loadBundle(locale: string): Promise<void>;
+    /**
+     * Register custom string overrides
+     * These take the highest priority in the merge chain
+     * @param overrides - Partial string overrides for any component
+     */
+    setOverrides(overrides: Partial<ILibraryStrings>): void;
+    /**
+     * Change the active locale
+     * Triggers bundle loading if the locale hasn't been loaded yet
+     * @param locale - The new locale code
+     * @returns A promise that resolves when the locale is active
+     */
+    setLocale(locale: string): Promise<void>;
+}
+//# sourceMappingURL=ILocalizationProvider.d.ts.map

package/dist/abstractions/index.d.ts

@@ -4,4 +4,5 @@ export * from './IGraphProvider';
 export * from './IAuthenticationProvider';
 export * from './ILoggingProvider';
 export * from './IStorageProvider';
+export * from './ILocalizationProvider';
 //# sourceMappingURL=index.d.ts.map

package/dist/abstractions/providers/DefaultLocalizationProvider.d.ts

@@ -0,0 +1,52 @@
+import { ILocalizationProvider } from '../ILocalizationProvider';
+import { ILibraryStrings } from '../../localization/ILibraryStrings';
+
+/**
+ * Default localization provider
+ * Follows the same pattern as ConsoleLoggingProvider, LocalStorageProvider
+ *
+ * Merge chain: English defaults ← language bundle ← explicit overrides
+ *
+ * @example
+ * ```ts
+ * const provider = new DefaultLocalizationProvider('pt');
+ * await provider.loadBundle('pt');
+ * const strings = provider.getStrings();
+ * ```
+ */
+export declare class DefaultLocalizationProvider implements ILocalizationProvider {
+    private _locale;
+    private _isRtl;
+    private _loadedBundles;
+    private _overrides;
+    constructor(locale?: string);
+    get locale(): string;
+    get isRtl(): boolean;
+    getStrings(): ILibraryStrings;
+    getComponentStrings<K extends keyof ILibraryStrings>(namespace: K): ILibraryStrings[K];
+    loadBundle(locale: string): Promise<void>;
+    setOverrides(overrides: Partial<ILibraryStrings>): void;
+    setLocale(locale: string): Promise<void>;
+    /**
+     * Auto-detect locale from the browser environment
+     * Priority: navigator.language → 'en'
+     */
+    static detectLocale(): string;
+    /**
+     * Detect locale from SPFx ICultureInfo
+     * Priority: cultureInfo.currentUICultureName → cultureInfo.currentCultureName → detectLocale()
+     */
+    static detectLocaleFromCulture(cultureInfo?: {
+        currentCultureName?: string;
+        currentUICultureName?: string;
+    }): string;
+    /**
+     * Check if a locale is RTL
+     */
+    static isRtlLocale(locale: string): boolean;
+    /**
+     * Extract the base language key from a locale string (e.g., 'pt-BR' → 'pt')
+     */
+    private getLanguageKey;
+}
+//# sourceMappingURL=DefaultLocalizationProvider.d.ts.map