@powerportalspro/react 5.0.0-beta.3 → 5.0.0

package/dist/index.cjs

@@ -4,7 +4,273 @@ var react = require('react');
 var core = require('@powerportalspro/core');
 var jsxRuntime = require('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 = react.useRef({
+    mode,
+    pattern,
+    allowedPattern,
+    numeric,
+    valueIncludesMask
+  });
+  optionsRef.current = { mode, pattern, allowedPattern, numeric, valueIncludesMask };
+  const onValueChangeRef = react.useRef(onValueChange);
+  onValueChangeRef.current = onValueChange;
+  const elementRef = react.useRef(null);
+  const focusedRef = react.useRef(false);
+  const hasInputSinceFocusRef = react.useRef(false);
+  const lastReportedRef = react.useRef(null);
+  const pendingCaretRef = react.useRef(null);
+  const [displayValue, setDisplayValue] = react.useState(
+    () => computeDisplay(value, optionsRef.current)
+  );
+  react.useEffect(() => {
+    if (focusedRef.current && hasInputSinceFocusRef.current) return;
+    const next = computeDisplay(value, optionsRef.current);
+    setDisplayValue(next);
+    lastReportedRef.current = computeReported(value, optionsRef.current);
+  }, [value]);
+  react.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]);
+  react.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 = react.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 = react.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 = react.useRef(() => {
+  });
+  handleFocusRef.current = () => {
+    focusedRef.current = true;
+    hasInputSinceFocusRef.current = false;
+  };
+  const handleBlurRef = react.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 = react.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",
@@ -78,19 +344,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 {
@@ -257,6 +523,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,
@@ -311,6 +602,12 @@ var LocaleContext = react.createContext(null);
 LocaleContext.displayName = "Locale";
 var LocalizationManifestContext = react.createContext(null);
 LocalizationManifestContext.displayName = "LocalizationManifest";
+function useUrlCultureStrategy() {
+  return react.useContext(LocalizationManifestContext)?.urlCultureStrategy;
+}
+function useDefaultLocale() {
+  return react.useContext(LocalizationManifestContext)?.supportedLocales?.[0];
+}
 function useLocale() {
   const ctx = react.useContext(LocaleContext);
   return ctx ?? { locale: "en", setLocale: noopSetLocale };
@@ -358,6 +655,9 @@ function DefaultLocalizerProvider({
 }) {
   const [cache, setCache] = react.useState({});
   const [supportedLocales, setSupportedLocales] = react.useState(void 0);
+  const [urlCultureStrategy, setUrlCultureStrategy] = react.useState(
+    void 0
+  );
   const { locale } = useLocale();
   const { ppp } = usePowerPortalsPro();
   const localeRef = react.useRef(locale);
@@ -427,6 +727,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;
@@ -615,8 +916,8 @@ function DefaultLocalizerProvider({
     [flushPending]
   );
   const manifestContextValue = react.useMemo(
-    () => ({ supportedLocales }),
-    [supportedLocales]
+    () => ({ supportedLocales, urlCultureStrategy }),
+    [supportedLocales, urlCultureStrategy]
   );
   return /* @__PURE__ */ jsxRuntime.jsx(LocalizationManifestContext.Provider, { value: manifestContextValue, children: /* @__PURE__ */ jsxRuntime.jsx(LocalizationPrefetcherContext.Provider, { value: prefetcher, children: /* @__PURE__ */ jsxRuntime.jsx(LocalizerProvider, { value: localizer, children }) }) });
 }
@@ -685,7 +986,7 @@ function PowerPortalsProProvider({
   tableMetadataCache,
   viewMetadataCache,
   viewsForTableCache,
-  environmentFileSettingsCache
+  organizationSettingsCache
 }) {
   const transportRef = react.useRef(null);
   if (transportRef.current === null) {
@@ -706,9 +1007,9 @@ function PowerPortalsProProvider({
     () => viewsForTableCache ?? new InMemoryViewsForTableCache(ppp),
     [ppp, viewsForTableCache]
   );
-  const resolvedEnvironmentFileSettingsCache = react.useMemo(
-    () => environmentFileSettingsCache ?? new InMemoryEnvironmentFileSettingsCache(ppp),
-    [ppp, environmentFileSettingsCache]
+  const resolvedOrganizationSettingsCache = react.useMemo(
+    () => organizationSettingsCache ?? new InMemoryOrganizationSettingsCache(ppp),
+    [ppp, organizationSettingsCache]
   );
   const [authState, setAuthState] = react.useState({ status: AuthStatus.Loading });
   const refreshAuth = react.useCallback(async () => {
@@ -755,7 +1056,7 @@ function PowerPortalsProProvider({
       tableMetadataCache: resolvedTableMetadataCache,
       viewMetadataCache: resolvedViewMetadataCache,
       viewsForTableCache: resolvedViewsForTableCache,
-      environmentFileSettingsCache: resolvedEnvironmentFileSettingsCache,
+      organizationSettingsCache: resolvedOrganizationSettingsCache,
       authState,
       refreshAuth,
       login,
@@ -769,7 +1070,7 @@ function PowerPortalsProProvider({
       resolvedTableMetadataCache,
       resolvedViewMetadataCache,
       resolvedViewsForTableCache,
-      resolvedEnvironmentFileSettingsCache,
+      resolvedOrganizationSettingsCache,
       authState,
       refreshAuth,
       login,
@@ -804,7 +1105,7 @@ function CacheLocaleSync() {
     tableMetadataCache,
     viewMetadataCache,
     viewsForTableCache,
-    environmentFileSettingsCache
+    organizationSettingsCache
   } = usePowerPortalsPro();
   const isFirstRun = react.useRef(true);
   react.useEffect(() => {
@@ -815,13 +1116,13 @@ function CacheLocaleSync() {
     tableMetadataCache.clear();
     viewMetadataCache.clear();
     viewsForTableCache.clear();
-    environmentFileSettingsCache.invalidate();
+    organizationSettingsCache.invalidate();
   }, [
     locale,
     tableMetadataCache,
     viewMetadataCache,
     viewsForTableCache,
-    environmentFileSettingsCache
+    organizationSettingsCache
   ]);
   return null;
 }
@@ -1230,16 +1531,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
   );
 }
@@ -1623,10 +1924,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 };
@@ -1757,7 +2056,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;
@@ -1833,6 +2132,44 @@ function RecordContextInner({
       (current) => current ? { ...current, properties: nextProperties } : current
     );
   }, [isCreateMode, queryParameterName, metadataQuery.data, loadedRecord]);
+  react.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]);
   react.useEffect(() => {
     if (!isSkipFetchMode || !loadedRecordProp) return;
     setLoadedRecord(loadedRecordProp);
@@ -1905,10 +2242,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).
@@ -2266,7 +2603,7 @@ exports.AuthorizedView = AuthorizedView;
 exports.DEFAULT_URL_LOCALE_PATTERN = DEFAULT_URL_LOCALE_PATTERN;
 exports.DefaultLocalizerProvider = DefaultLocalizerProvider;
 exports.DialogServiceProvider = DialogServiceProvider;
-exports.InMemoryEnvironmentFileSettingsCache = InMemoryEnvironmentFileSettingsCache;
+exports.InMemoryOrganizationSettingsCache = InMemoryOrganizationSettingsCache;
 exports.InMemoryTableMetadataCache = InMemoryTableMetadataCache;
 exports.InMemoryViewMetadataCache = InMemoryViewMetadataCache;
 exports.InMemoryViewsForTableCache = InMemoryViewsForTableCache;
@@ -2275,6 +2612,7 @@ exports.LocalizerProvider = LocalizerProvider;
 exports.LookupRecordContext = LookupRecordContext;
 exports.MainContext = MainContext;
 exports.MainContextProvider = MainContextProvider;
+exports.MaskMode = MaskMode;
 exports.OverlayServiceProvider = OverlayServiceProvider;
 exports.PowerPortalsProContext = PowerPortalsProContext;
 exports.PowerPortalsProProvider = PowerPortalsProProvider;
@@ -2283,20 +2621,24 @@ exports.RecordContext = RecordContext;
 exports.UnsavedChangesRegistryProvider = UnsavedChangesRegistryProvider;
 exports.VERSION = VERSION;
 exports.ValidationProvider = ValidationProvider;
+exports.buildLocalePath = buildLocalePath;
 exports.createLocalizer = createLocalizer;
 exports.detectLocale = detectLocale;
 exports.flattenStrings = flattenStrings;
 exports.getAspNetCultureCookie = getAspNetCultureCookie;
 exports.getLocaleFromUrlPath = getLocaleFromUrlPath;
 exports.interpolate = interpolate;
+exports.reformat = reformat;
 exports.resolveLocalizationUrl = resolveLocalizationUrl;
 exports.runWithOverlayAsync = runWithOverlayAsync;
 exports.setAspNetCultureCookie = setAspNetCultureCookie;
+exports.shouldPrefixLocale = shouldPrefixLocale;
+exports.stripLocalePrefix = stripLocalePrefix;
 exports.useAuth = useAuth;
 exports.useColumnMetadata = useColumnMetadata;
 exports.useColumnValidationErrors = useColumnValidationErrors;
+exports.useDefaultLocale = useDefaultLocale;
 exports.useDialogService = useDialogService;
-exports.useEnvironmentFileSettings = useEnvironmentFileSettings;
 exports.useFetchRecords = useFetchRecords;
 exports.useGridData = useGridData;
 exports.useIsAnyDirty = useIsAnyDirty;
@@ -2306,6 +2648,8 @@ exports.useLocalizationLoaded = useLocalizationLoaded;
 exports.useLocalizationPrefetcher = useLocalizationPrefetcher;
 exports.useLocalizer = useLocalizer;
 exports.useMainContext = useMainContext;
+exports.useMaskedTextField = useMaskedTextField;
+exports.useOrganizationSettings = useOrganizationSettings;
 exports.useOverlayForTarget = useOverlayForTarget;
 exports.useOverlayService = useOverlayService;
 exports.useOverlayServiceState = useOverlayServiceState;
@@ -2323,6 +2667,7 @@ exports.useTablePermissions = useTablePermissions;
 exports.useUnsavedChangesGuard = useUnsavedChangesGuard;
 exports.useUnsavedChangesRegistry = useUnsavedChangesRegistry;
 exports.useUnsavedChangesWarning = useUnsavedChangesWarning;
+exports.useUrlCultureStrategy = useUrlCultureStrategy;
 exports.useValidationContext = useValidationContext;
 exports.useViewDataSource = useViewDataSource;
 exports.useViewMetadata = useViewMetadata;