@powerportalspro/react 5.0.0-beta.3 → 5.1.0

package/dist/index.js

@@ -1,8 +1,274 @@
-import { createContext, useContext, useCallback, useMemo, useEffect, useSyncExternalStore, useState, useRef, useReducer, useId } from 'react';
+import { createContext, useRef, useState, useEffect, useLayoutEffect, useCallback, useContext, useMemo, useSyncExternalStore, useReducer, useId } from 'react';
 import { Transport, AuthClient, PowerPortalsProClient, LoginResult, SwitchIdentityResult } from '@powerportalspro/core';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 
-// src/context.ts
+// src/masking/reformat.ts
+var MaskMode = {
+  /** No masking — value passes through unchanged. */
+  None: "none",
+  /**
+   * Per-character allow filter. Characters that don't match
+   * {@link MaskOptions.allowedPattern} are dropped as they're typed or pasted.
+   */
+  Regex: "regex",
+  /**
+   * Slotted template (see {@link MaskOptions.pattern}) such as `(000) 000-0000`.
+   * `0` = digit, `A` = letter, `*` = alphanumeric; every other character is a
+   * literal inserted automatically.
+   */
+  Pattern: "pattern",
+  /**
+   * Live numeric grouping driven by {@link MaskOptions.numeric} — thousands
+   * separators, an optional decimal portion, and an optional leading sign.
+   */
+  Numeric: "numeric"
+};
+var DIGIT = /[0-9]/;
+var LETTER = /[a-zA-Z]/;
+var ALNUM = /[a-zA-Z0-9]/;
+function isPatternLiteral(token) {
+  return token !== "0" && token !== "A" && token !== "*";
+}
+function patternTokenMatches(token, ch) {
+  if (token === "0") return DIGIT.test(ch);
+  if (token === "A") return LETTER.test(ch);
+  if (token === "*") return ALNUM.test(ch);
+  return false;
+}
+function countSignificant(source, caret, isSignificant) {
+  let n = 0;
+  for (let i = 0; i < caret && i < source.length; i++) {
+    if (isSignificant(source.charAt(i))) n++;
+  }
+  return n;
+}
+function caretAfterSignificant(display, target, isSignificant) {
+  if (target <= 0) {
+    let i = 0;
+    while (i < display.length && !isSignificant(display.charAt(i))) i++;
+    return i;
+  }
+  let seen = 0;
+  for (let i = 0; i < display.length; i++) {
+    if (isSignificant(display.charAt(i))) {
+      seen++;
+      if (seen === target) return i + 1;
+    }
+  }
+  return display.length;
+}
+function reformatNumeric(value, caret, o) {
+  const sigChars = (c) => DIGIT.test(c) || c === o.decimalSeparator || o.allowNegative && c === "-";
+  const sigBefore = countSignificant(value, caret, sigChars);
+  const negative = o.allowNegative && value.trimStart().startsWith("-");
+  let intPart = "";
+  let fracPart = "";
+  let sawDecimal = false;
+  for (const ch of value) {
+    if (DIGIT.test(ch)) {
+      if (sawDecimal) fracPart += ch;
+      else intPart += ch;
+    } else if (o.allowDecimal && ch === o.decimalSeparator && !sawDecimal) {
+      sawDecimal = true;
+    }
+  }
+  intPart = intPart.replace(/^0+(?=\d)/, "");
+  if (o.maxDecimals !== null && fracPart.length > o.maxDecimals) {
+    fracPart = fracPart.slice(0, o.maxDecimals);
+  }
+  const grouped = o.groupSeparator ? intPart.replace(/\B(?=(\d{3})+(?!\d))/g, o.groupSeparator) : intPart;
+  const sign = negative ? "-" : "";
+  let display = sign + grouped;
+  let raw = sign + intPart;
+  if (sawDecimal) {
+    display += o.decimalSeparator + fracPart;
+    raw += o.decimalSeparator + fracPart;
+  }
+  const newCaret = caretAfterSignificant(display, sigBefore, sigChars);
+  return { display, raw, caret: newCaret };
+}
+function reformatPattern(value, caret, pattern) {
+  const sourceChars = [];
+  for (const ch of value) {
+    if (DIGIT.test(ch) || LETTER.test(ch)) sourceChars.push(ch);
+  }
+  const sigBefore = countSignificant(value, caret, (c) => DIGIT.test(c) || LETTER.test(c));
+  let display = "";
+  let raw = "";
+  let si = 0;
+  for (let pi = 0; pi < pattern.length && si <= sourceChars.length; pi++) {
+    const token = pattern[pi];
+    if (isPatternLiteral(token)) {
+      if (si < sourceChars.length) display += token;
+      continue;
+    }
+    while (si < sourceChars.length && !patternTokenMatches(token, sourceChars[si])) si++;
+    if (si < sourceChars.length) {
+      display += sourceChars[si];
+      raw += sourceChars[si];
+      si++;
+    } else {
+      break;
+    }
+  }
+  const newCaret = caretAfterSignificant(display, sigBefore, (c) => DIGIT.test(c) || LETTER.test(c));
+  return { display, raw, caret: newCaret };
+}
+function reformatRegex(value, caret, allowedPattern) {
+  let re;
+  try {
+    re = new RegExp(allowedPattern);
+  } catch {
+    return { display: value, raw: value, caret };
+  }
+  const keep = (c) => re.test(c);
+  const sigBefore = countSignificant(value, caret, keep);
+  let display = "";
+  for (const ch of value) {
+    if (keep(ch)) display += ch;
+  }
+  const newCaret = caretAfterSignificant(display, sigBefore, keep);
+  return { display, raw: display, caret: newCaret };
+}
+function reformat(value, caret, options) {
+  switch (options.mode) {
+    case MaskMode.Numeric:
+      return options.numeric ? reformatNumeric(value, caret, options.numeric) : { display: value, raw: value, caret };
+    case MaskMode.Pattern:
+      return options.pattern ? reformatPattern(value, caret, options.pattern) : { display: value, raw: value, caret };
+    case MaskMode.Regex:
+      return options.allowedPattern ? reformatRegex(value, caret, options.allowedPattern) : { display: value, raw: value, caret };
+    default:
+      return { display: value, raw: value, caret };
+  }
+}
+function computeDisplay(value, options) {
+  if (value === null || value === void 0 || value === "") return "";
+  return reformat(value, value.length, options).display;
+}
+function computeReported(value, options) {
+  if (value === null || value === void 0 || value === "") return "";
+  const r = reformat(value, value.length, options);
+  return options.valueIncludesMask ? r.display : r.raw;
+}
+function useMaskedTextField(opts) {
+  const {
+    value,
+    onValueChange,
+    mode = MaskMode.None,
+    pattern = null,
+    allowedPattern = null,
+    numeric = null,
+    valueIncludesMask = false
+  } = opts;
+  const optionsRef = useRef({
+    mode,
+    pattern,
+    allowedPattern,
+    numeric,
+    valueIncludesMask
+  });
+  optionsRef.current = { mode, pattern, allowedPattern, numeric, valueIncludesMask };
+  const onValueChangeRef = useRef(onValueChange);
+  onValueChangeRef.current = onValueChange;
+  const elementRef = useRef(null);
+  const focusedRef = useRef(false);
+  const hasInputSinceFocusRef = useRef(false);
+  const lastReportedRef = useRef(null);
+  const pendingCaretRef = useRef(null);
+  const [displayValue, setDisplayValue] = useState(
+    () => computeDisplay(value, optionsRef.current)
+  );
+  useEffect(() => {
+    if (focusedRef.current && hasInputSinceFocusRef.current) return;
+    const next = computeDisplay(value, optionsRef.current);
+    setDisplayValue(next);
+    lastReportedRef.current = computeReported(value, optionsRef.current);
+  }, [value]);
+  useEffect(() => {
+    if (focusedRef.current && hasInputSinceFocusRef.current) return;
+    const next = computeDisplay(value, optionsRef.current);
+    setDisplayValue(next);
+    lastReportedRef.current = computeReported(value, optionsRef.current);
+  }, [mode, pattern, allowedPattern, numeric, valueIncludesMask]);
+  useLayoutEffect(() => {
+    const target = pendingCaretRef.current;
+    if (target === null) return;
+    const input = elementRef.current;
+    if (!input) return;
+    try {
+      input.setSelectionRange(target, target);
+    } catch {
+    }
+    pendingCaretRef.current = null;
+  });
+  const onChange = useCallback(
+    (_event, data) => {
+      hasInputSinceFocusRef.current = true;
+      const o = optionsRef.current;
+      const input = elementRef.current;
+      const caret = input?.selectionStart ?? data.value.length;
+      const result = reformat(data.value, caret, o);
+      setDisplayValue(result.display);
+      pendingCaretRef.current = result.caret;
+      const reported = o.valueIncludesMask ? result.display : result.raw;
+      const empty = reported === "";
+      const next = empty ? null : reported;
+      if (reported !== lastReportedRef.current) {
+        lastReportedRef.current = reported;
+        onValueChangeRef.current(next);
+      }
+    },
+    []
+  );
+  const inputRef = useCallback((el) => {
+    const prev = elementRef.current;
+    if (prev && prev !== el) {
+      prev.removeEventListener("focus", handleFocusRef.current);
+      prev.removeEventListener("blur", handleBlurRef.current);
+    }
+    elementRef.current = el;
+    if (el) {
+      el.addEventListener("focus", handleFocusRef.current);
+      el.addEventListener("blur", handleBlurRef.current);
+    }
+  }, []);
+  const handleFocusRef = useRef(() => {
+  });
+  handleFocusRef.current = () => {
+    focusedRef.current = true;
+    hasInputSinceFocusRef.current = false;
+  };
+  const handleBlurRef = useRef(() => {
+  });
+  handleBlurRef.current = () => {
+    focusedRef.current = false;
+    if (!hasInputSinceFocusRef.current) {
+      const next = computeDisplay(value, optionsRef.current);
+      if (next !== displayValue) {
+        setDisplayValue(next);
+        lastReportedRef.current = computeReported(value, optionsRef.current);
+      }
+    }
+  };
+  const forceValue = useCallback((newValue) => {
+    const o = optionsRef.current;
+    if (newValue === null || newValue === "") {
+      setDisplayValue("");
+      lastReportedRef.current = "";
+      pendingCaretRef.current = 0;
+      onValueChangeRef.current(null);
+      return;
+    }
+    const result = reformat(newValue, newValue.length, o);
+    setDisplayValue(result.display);
+    pendingCaretRef.current = result.display.length;
+    const reported = o.valueIncludesMask ? result.display : result.raw;
+    lastReportedRef.current = reported;
+    onValueChangeRef.current(reported === "" ? null : reported);
+  }, []);
+  return { displayValue, onChange, inputRef, forceValue };
+}
 var AuthStatus = {
   Loading: "loading",
   Anonymous: "anonymous",
@@ -76,19 +342,19 @@ var InMemoryViewMetadataCache = class {
     this.cache.clear();
   }
 };
-var InMemoryEnvironmentFileSettingsCache = class _InMemoryEnvironmentFileSettingsCache {
-  static KEY = "environment-file-settings";
+var InMemoryOrganizationSettingsCache = class _InMemoryOrganizationSettingsCache {
+  static KEY = "organization-settings";
   cache;
   constructor(ppp) {
     this.cache = new InMemoryCache(
-      () => ppp.getEnvironmentFileSettingsAsync()
+      () => ppp.getOrganizationSettingsAsync()
     );
   }
   getAsync() {
-    return this.cache.getAsync(_InMemoryEnvironmentFileSettingsCache.KEY);
+    return this.cache.getAsync(_InMemoryOrganizationSettingsCache.KEY);
   }
   invalidate() {
-    this.cache.invalidate(_InMemoryEnvironmentFileSettingsCache.KEY);
+    this.cache.invalidate(_InMemoryOrganizationSettingsCache.KEY);
   }
 };
 var InMemoryViewsForTableCache = class {
@@ -255,6 +521,31 @@ function getLocaleFromUrlPath(pattern = DEFAULT_URL_LOCALE_PATTERN) {
   const match = window.location.pathname.match(pattern);
   return match?.[1] ?? null;
 }
+function shouldPrefixLocale(strategy, locale, defaultLocale) {
+  switch (strategy) {
+    case "CookieOnly":
+      return false;
+    case "PathPrefixAll":
+      return true;
+    default:
+      return locale.toLowerCase() !== defaultLocale.toLowerCase();
+  }
+}
+function stripLocalePrefix(pathname, supportedLocales) {
+  const trimmed = pathname.replace(/^\/+/, "");
+  if (trimmed.length === 0) return "/";
+  const slash = trimmed.indexOf("/");
+  const first = slash < 0 ? trimmed : trimmed.slice(0, slash);
+  const isLocale = supportedLocales.some((l) => l.toLowerCase() === first.toLowerCase());
+  if (!isLocale) return pathname.startsWith("/") ? pathname : `/${pathname}`;
+  const rest = slash < 0 ? "" : trimmed.slice(slash);
+  return rest.length === 0 ? "/" : rest;
+}
+function buildLocalePath(options) {
+  const { strategy, locale, defaultLocale, pathname, supportedLocales } = options;
+  const cultureless = stripLocalePrefix(pathname, supportedLocales);
+  return shouldPrefixLocale(strategy, locale, defaultLocale) ? `/${locale}${cultureless}` : cultureless;
+}
 function detectLocale(options) {
   const {
     matchUrl = true,
@@ -309,6 +600,12 @@ var LocaleContext = createContext(null);
 LocaleContext.displayName = "Locale";
 var LocalizationManifestContext = createContext(null);
 LocalizationManifestContext.displayName = "LocalizationManifest";
+function useUrlCultureStrategy() {
+  return useContext(LocalizationManifestContext)?.urlCultureStrategy;
+}
+function useDefaultLocale() {
+  return useContext(LocalizationManifestContext)?.supportedLocales?.[0];
+}
 function useLocale() {
   const ctx = useContext(LocaleContext);
   return ctx ?? { locale: "en", setLocale: noopSetLocale };
@@ -356,6 +653,9 @@ function DefaultLocalizerProvider({
 }) {
   const [cache, setCache] = useState({});
   const [supportedLocales, setSupportedLocales] = useState(void 0);
+  const [urlCultureStrategy, setUrlCultureStrategy] = useState(
+    void 0
+  );
   const { locale } = useLocale();
   const { ppp } = usePowerPortalsPro();
   const localeRef = useRef(locale);
@@ -425,6 +725,7 @@ function DefaultLocalizerProvider({
         const manifest = await pppRef.current.retrieveLocalizationBundleManifestAsync();
         if (cancelled) return;
         setSupportedLocales(manifest.supportedLocales);
+        setUrlCultureStrategy(manifest.urlCultureStrategy);
         const resolvedLocale = manifest.supportedLocales.includes(locale) ? locale : manifest.supportedLocales[0] ?? locale;
         const thumbs = await pppRef.current.retrieveLocalizationThumbprintsAsync(resolvedLocale);
         if (cancelled) return;
@@ -613,8 +914,8 @@ function DefaultLocalizerProvider({
     [flushPending]
   );
   const manifestContextValue = useMemo(
-    () => ({ supportedLocales }),
-    [supportedLocales]
+    () => ({ supportedLocales, urlCultureStrategy }),
+    [supportedLocales, urlCultureStrategy]
   );
   return /* @__PURE__ */ jsx(LocalizationManifestContext.Provider, { value: manifestContextValue, children: /* @__PURE__ */ jsx(LocalizationPrefetcherContext.Provider, { value: prefetcher, children: /* @__PURE__ */ jsx(LocalizerProvider, { value: localizer, children }) }) });
 }
@@ -683,7 +984,7 @@ function PowerPortalsProProvider({
   tableMetadataCache,
   viewMetadataCache,
   viewsForTableCache,
-  environmentFileSettingsCache
+  organizationSettingsCache
 }) {
   const transportRef = useRef(null);
   if (transportRef.current === null) {
@@ -704,9 +1005,9 @@ function PowerPortalsProProvider({
     () => viewsForTableCache ?? new InMemoryViewsForTableCache(ppp),
     [ppp, viewsForTableCache]
   );
-  const resolvedEnvironmentFileSettingsCache = useMemo(
-    () => environmentFileSettingsCache ?? new InMemoryEnvironmentFileSettingsCache(ppp),
-    [ppp, environmentFileSettingsCache]
+  const resolvedOrganizationSettingsCache = useMemo(
+    () => organizationSettingsCache ?? new InMemoryOrganizationSettingsCache(ppp),
+    [ppp, organizationSettingsCache]
   );
   const [authState, setAuthState] = useState({ status: AuthStatus.Loading });
   const refreshAuth = useCallback(async () => {
@@ -753,7 +1054,7 @@ function PowerPortalsProProvider({
       tableMetadataCache: resolvedTableMetadataCache,
       viewMetadataCache: resolvedViewMetadataCache,
       viewsForTableCache: resolvedViewsForTableCache,
-      environmentFileSettingsCache: resolvedEnvironmentFileSettingsCache,
+      organizationSettingsCache: resolvedOrganizationSettingsCache,
       authState,
       refreshAuth,
       login,
@@ -767,7 +1068,7 @@ function PowerPortalsProProvider({
       resolvedTableMetadataCache,
       resolvedViewMetadataCache,
       resolvedViewsForTableCache,
-      resolvedEnvironmentFileSettingsCache,
+      resolvedOrganizationSettingsCache,
       authState,
       refreshAuth,
       login,
@@ -802,7 +1103,7 @@ function CacheLocaleSync() {
     tableMetadataCache,
     viewMetadataCache,
     viewsForTableCache,
-    environmentFileSettingsCache
+    organizationSettingsCache
   } = usePowerPortalsPro();
   const isFirstRun = useRef(true);
   useEffect(() => {
@@ -813,13 +1114,13 @@ function CacheLocaleSync() {
     tableMetadataCache.clear();
     viewMetadataCache.clear();
     viewsForTableCache.clear();
-    environmentFileSettingsCache.invalidate();
+    organizationSettingsCache.invalidate();
   }, [
     locale,
     tableMetadataCache,
     viewMetadataCache,
     viewsForTableCache,
-    environmentFileSettingsCache
+    organizationSettingsCache
   ]);
   return null;
 }
@@ -1228,16 +1529,16 @@ function useViewsForTable(tableLogicalName, options) {
   );
 }
 
-// src/use-environment-file-settings.ts
-function useEnvironmentFileSettings(options) {
-  const { environmentFileSettingsCache } = usePowerPortalsPro();
+// src/use-organization-settings.ts
+function useOrganizationSettings(options) {
+  const { organizationSettingsCache } = usePowerPortalsPro();
   const enabled = options?.enabled ?? true;
   return useAsyncResource(
     async () => {
-      const result = await environmentFileSettingsCache.getAsync();
+      const result = await organizationSettingsCache.getAsync();
       return result ?? void 0;
     },
-    [environmentFileSettingsCache],
+    [organizationSettingsCache],
     enabled
   );
 }
@@ -1621,10 +1922,8 @@ function valuesEqual(a, b) {
 var GUID_PATTERN = /^\{?[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\}?$/i;
 function parseQueryDefault(metadata, rawValue) {
   switch (metadata.$type) {
-    // StringMetadata + MemoMetadata both ride on StringValue. In Blazor
-    // MemoMetadata derives from StringMetadata so a single `StringMetadata`
-    // pattern catches both; in TS the discriminators are distinct so we
-    // list both arms.
+    // StringMetadata + MemoMetadata both ride on StringValue. The TS
+    // discriminators are distinct so we list both arms.
     case 14:
     case 7:
       return { $type: 14, value: rawValue };
@@ -1755,7 +2054,7 @@ function RecordContextInner({
   }, [resolvedId, propIsEmptyId]);
   const isCreateMode = effectiveId === void 0;
   const isSkipFetchMode = !isCreateMode && loadedRecordProp !== void 0;
-  const { ppp } = usePowerPortalsPro();
+  const { ppp, organizationSettingsCache } = usePowerPortalsPro();
   const mainContext = useMainContext();
   const validation = useValidationContext();
   const isTopMost = mainContext === null;
@@ -1831,6 +2130,44 @@ function RecordContextInner({
       (current) => current ? { ...current, properties: nextProperties } : current
     );
   }, [isCreateMode, queryParameterName, metadataQuery.data, loadedRecord]);
+  useEffect(() => {
+    if (!isCreateMode) return;
+    if (!metadataQuery.data) return;
+    if (!loadedRecord) return;
+    if (pendingChangesRef.current.size > 0) return;
+    if (loadedRecord.currency) return;
+    let cancelled = false;
+    (async () => {
+      try {
+        const settings = await organizationSettingsCache.getAsync();
+        if (cancelled) return;
+        const defaultCurrency = settings?.defaultCurrency;
+        if (!defaultCurrency) return;
+        const tableHasCurrencyLookup = metadataQuery.data.columns?.some((c) => c.columnName === "transactioncurrencyid") ?? false;
+        setLoadedRecord((current) => {
+          if (!current) return current;
+          if (current.currency) return current;
+          const nextProperties = {
+            ...current.properties ?? {}
+          };
+          if (tableHasCurrencyLookup && !nextProperties["transactioncurrencyid"]) {
+            nextProperties["transactioncurrencyid"] = {
+              $type: 6,
+              // ColumnType.Lookup — matches the discriminator on LookupValue
+              value: defaultCurrency.id,
+              tableName: "transactioncurrency",
+              name: defaultCurrency.name
+            };
+          }
+          return { ...current, currency: defaultCurrency, properties: nextProperties };
+        });
+      } catch {
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [isCreateMode, metadataQuery.data, loadedRecord, organizationSettingsCache]);
   useEffect(() => {
     if (!isSkipFetchMode || !loadedRecordProp) return;
     setLoadedRecord(loadedRecordProp);
@@ -1903,10 +2240,10 @@ function RecordContextInner({
         record: {
           tableName: current.tableName,
           // Include the client-pre-generated GUID. The seed effect writes
-          // it into `_idForCreate` (Blazor parity); the server's in-batch
-          // resolver matches AssociateRequest / child-FK references
-          // against either `id` or `_idForCreate`, so a Create + Associate
-          // pair within one `ExecuteMultiple` resolves to the same record.
+          // it into `_idForCreate`; the server's in-batch resolver matches
+          // AssociateRequest / child-FK references against either `id` or
+          // `_idForCreate`, so a Create + Associate pair within one
+          // `ExecuteMultiple` resolves to the same record.
           // `id` is also forwarded when the consumer supplied an explicit
           // one via `initialRecord` (rare — pre-assigned ids on data
           // import).
@@ -2258,6 +2595,6 @@ function useUnsavedChangesGuard() {
 // src/index.ts
 var VERSION = "0.1.0";
 
-export { ASP_NET_CULTURE_COOKIE, AuthStatus, AuthorizedView, DEFAULT_URL_LOCALE_PATTERN, DefaultLocalizerProvider, DialogServiceProvider, InMemoryEnvironmentFileSettingsCache, InMemoryTableMetadataCache, InMemoryViewMetadataCache, InMemoryViewsForTableCache, LocaleProvider, LocalizerProvider, LookupRecordContext, MainContext, MainContextProvider, OverlayServiceProvider, PowerPortalsProContext, PowerPortalsProProvider, QueryStatus, RecordContext, UnsavedChangesRegistryProvider, VERSION, ValidationProvider, createLocalizer, detectLocale, flattenStrings, getAspNetCultureCookie, getLocaleFromUrlPath, interpolate, resolveLocalizationUrl, runWithOverlayAsync, setAspNetCultureCookie, useAuth, useColumnMetadata, useColumnValidationErrors, useDialogService, useEnvironmentFileSettings, useFetchRecords, useGridData, useIsAnyDirty, useLocale, useLocalization, useLocalizationLoaded, useLocalizationPrefetcher, useLocalizer, useMainContext, useOverlayForTarget, useOverlayService, useOverlayServiceState, usePowerPortalsPro, usePrefixedT, useQueryParam, useRecord, useRecordContext, useRecordContextOptional, useRunWithOverlay, useSupportedLocales, useT, useTableMetadata, useTablePermissions, useUnsavedChangesGuard, useUnsavedChangesRegistry, useUnsavedChangesWarning, useValidationContext, useViewDataSource, useViewMetadata, useViewsForTable, useWarnAboutUnsavedChanges, warnAboutUnsavedChangesAsync };
+export { ASP_NET_CULTURE_COOKIE, AuthStatus, AuthorizedView, DEFAULT_URL_LOCALE_PATTERN, DefaultLocalizerProvider, DialogServiceProvider, InMemoryOrganizationSettingsCache, InMemoryTableMetadataCache, InMemoryViewMetadataCache, InMemoryViewsForTableCache, LocaleProvider, LocalizerProvider, LookupRecordContext, MainContext, MainContextProvider, MaskMode, OverlayServiceProvider, PowerPortalsProContext, PowerPortalsProProvider, QueryStatus, RecordContext, UnsavedChangesRegistryProvider, VERSION, ValidationProvider, buildLocalePath, createLocalizer, detectLocale, flattenStrings, getAspNetCultureCookie, getLocaleFromUrlPath, interpolate, reformat, resolveLocalizationUrl, runWithOverlayAsync, setAspNetCultureCookie, shouldPrefixLocale, stripLocalePrefix, useAuth, useColumnMetadata, useColumnValidationErrors, useDefaultLocale, useDialogService, useFetchRecords, useGridData, useIsAnyDirty, useLocale, useLocalization, useLocalizationLoaded, useLocalizationPrefetcher, useLocalizer, useMainContext, useMaskedTextField, useOrganizationSettings, useOverlayForTarget, useOverlayService, useOverlayServiceState, usePowerPortalsPro, usePrefixedT, useQueryParam, useRecord, useRecordContext, useRecordContextOptional, useRunWithOverlay, useSupportedLocales, useT, useTableMetadata, useTablePermissions, useUnsavedChangesGuard, useUnsavedChangesRegistry, useUnsavedChangesWarning, useUrlCultureStrategy, useValidationContext, useViewDataSource, useViewMetadata, useViewsForTable, useWarnAboutUnsavedChanges, warnAboutUnsavedChangesAsync };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map