cx 24.3.7 → 24.3.9

package/src/ui/Culture.js

@@ -1,76 +1,132 @@
-import { NumberCulture, DateTimeCulture } from "intl-io";
-import { Localization } from "./Localization";
-import { GlobalCacheIdentifier } from "../util/GlobalCacheIdentifier";
-import { invalidateExpressionCache } from "../data/Expression";
-import { invalidateStringTemplateCache } from "../data/StringTemplate";
-import { defaultCompare } from "../data/defaultCompare";
-
-let culture = "en";
-let numberCulture = null;
-let dateTimeCulture = null;
-let cultureCache = {};
-let defaultCurrency = "USD";
-let dateEncoding = (date) => date.toISOString();
-
-export class Culture {
-   static setCulture(cultureCode) {
-      culture = cultureCode;
-      cultureCache = {};
-      Localization.setCulture(cultureCode);
-      this.invalidateCache();
-   }
-
-   static setNumberCulture(cultureCode) {
-      numberCulture = cultureCode;
-      delete cultureCache.numberCulture;
-      this.invalidateCache();
-   }
-
-   static setDateTimeCulture(cultureCode) {
-      dateTimeCulture = cultureCode;
-      delete cultureCache.dateTimeCulture;
-      this.invalidateCache();
-   }
-
-   static setDefaultCurrency(currencyCode) {
-      defaultCurrency = currencyCode;
-      this.invalidateCache();
-   }
-
-   static invalidateCache() {
-      GlobalCacheIdentifier.change();
-      invalidateExpressionCache();
-      invalidateStringTemplateCache();
-   }
-
-   static get defaultCurrency() {
-      return defaultCurrency;
-   }
-
-   static get culture() {
-      return culture;
-   }
-
-   static getNumberCulture() {
-      if (!cultureCache.numberCulture) cultureCache.numberCulture = new NumberCulture(numberCulture ?? culture);
-      return cultureCache.numberCulture;
-   }
-
-   static getDateTimeCulture() {
-      if (!cultureCache.dateTimeCulture) cultureCache.dateTimeCulture = new DateTimeCulture(dateTimeCulture ?? culture);
-      return cultureCache.dateTimeCulture;
-   }
-
-   static getDefaultDateEncoding() {
-      return dateEncoding;
-   }
-
-   static setDefaultDateEncoding(encoding) {
-      dateEncoding = encoding;
-   }
-
-   static getComparer(options) {
-      if (typeof Intl.Collator != "undefined") return new Intl.Collator(culture, options).compare;
-      return defaultCompare;
-   }
-}
+import { NumberCulture, DateTimeCulture } from "intl-io";
+import { Localization } from "./Localization";
+import { GlobalCacheIdentifier } from "../util/GlobalCacheIdentifier";
+import { invalidateExpressionCache } from "../data/Expression";
+import { invalidateStringTemplateCache } from "../data/StringTemplate";
+import { defaultCompare } from "../data/defaultCompare";
+
+// let culture = "en";
+// let numberCulture = null;
+// let dateTimeCulture = null;
+// let cache = {};
+// let defaultCurrency = "USD";
+// let dateEncoding = (date) => date.toISOString();
+
+let stack = [
+   {
+      culture: "en",
+      numberCulture: null,
+      dateTimeCulture: null,
+      cache: {},
+      defaultCurrency: "USD",
+      dateEncoding: (date) => date.toISOString(),
+   },
+];
+
+function getRootCultureSpecs() {
+   return stack[0];
+}
+
+function getCurrentCultureSpecs() {
+   return stack[stack.length - 1];
+}
+
+export function getCurrentCultureCache() {
+   return getCurrentCultureSpecs().cache;
+}
+
+export function pushCulture(cultureInfo) {
+   stack.push(cultureInfo);
+}
+
+export function createCulture(cultureSpecs) {
+   let current = getCurrentCultureSpecs();
+   let info = {
+      culture: current.culture,
+      dateEncoding: current.dateEncoding,
+      defaultCurrency: current.defaultCurrency,
+      cache: {},
+   };
+   for (let key in cultureSpecs) {
+      if (!cultureSpecs[key]) continue;
+      info[key] = cultureSpecs[key];
+   }
+   return info;
+}
+
+export function popCulture() {
+   if (stack.length == 1) throw new Error("Cannot pop the last culture object.");
+   return stack.pop();
+}
+
+export class Culture {
+   static setCulture(cultureCode) {
+      let cultureSpecs = getRootCultureSpecs();
+      cultureSpecs.culture = cultureCode;
+      cultureSpecs.cache = {};
+      Localization.setCulture(cultureCode);
+      this.invalidateCache();
+   }
+
+   static setNumberCulture(cultureCode) {
+      let cultureSpecs = getRootCultureSpecs();
+      cultureSpecs.numberCulture = cultureCode;
+      delete cultureSpecs.cache.numberCulture;
+      this.invalidateCache();
+   }
+
+   static setDateTimeCulture(cultureCode) {
+      let cultureSpecs = getRootCultureSpecs();
+      cultureSpecs.dateTimeCulture = cultureCode;
+      delete cultureSpecs.cache.dateTimeCulture;
+      this.invalidateCache();
+   }
+
+   static setDefaultCurrency(currencyCode) {
+      let cultureSpecs = getRootCultureSpecs();
+      cultureSpecs.defaultCurrency = currencyCode;
+      this.invalidateCache();
+   }
+
+   static setDefaultDateEncoding(encoding) {
+      let cultureSpecs = getRootCultureSpecs();
+      cultureSpecs.dateEncoding = encoding;
+      this.invalidateCache();
+   }
+
+   static invalidateCache() {
+      GlobalCacheIdentifier.change();
+      invalidateExpressionCache();
+      invalidateStringTemplateCache();
+   }
+
+   static get defaultCurrency() {
+      return getCurrentCultureSpecs().defaultCurrency;
+   }
+
+   static get culture() {
+      return getCurrentCultureSpecs().culture;
+   }
+
+   static getNumberCulture() {
+      let { cache, numberCulture, culture } = getCurrentCultureSpecs();
+      if (!cache.numberCulture) cache.numberCulture = new NumberCulture(numberCulture ?? culture);
+      return cache.numberCulture;
+   }
+
+   static getDateTimeCulture() {
+      let { cache, dateTimeCulture, culture } = getCurrentCultureSpecs();
+      if (!cache.dateTimeCulture) cache.dateTimeCulture = new DateTimeCulture(dateTimeCulture ?? culture);
+      return cache.dateTimeCulture;
+   }
+
+   static getDefaultDateEncoding() {
+      return getCurrentCultureSpecs().dateEncoding;
+   }
+
+   static getComparer(options) {
+      let { culture } = getCurrentCultureSpecs();
+      if (typeof Intl.Collator != "undefined") return new Intl.Collator(culture, options).compare;
+      return defaultCompare;
+   }
+}

package/src/ui/CultureScope.d.ts

@@ -0,0 +1,10 @@
+import * as Cx from "../core";
+
+interface CultureScopeProps extends Cx.PureContainerProps {
+   culture: Cx.StringProp;
+   numberCulture: Cx.StringProp;
+   dateTimeCulture: Cx.StringProp;
+   defaultCurrency: Cx.StringProp;
+}
+
+export class CultureScope extends Cx.Widget<CultureScopeProps> {}

package/src/ui/CultureScope.js

@@ -0,0 +1,53 @@
+import { createCulture, popCulture, pushCulture } from "./Culture";
+import { PureContainer } from "./PureContainer";
+
+export class CultureScope extends PureContainer {
+   init() {
+      this.initialItems = this.items ?? this.children;
+      delete this.items;
+      delete this.children;
+      super.init();
+   }
+
+   declareData(...args) {
+      super.declareData(...args, {
+         culture: undefined,
+         numberCulture: undefined,
+         dateTimeCulture: undefined,
+         defaultCurrency: undefined,
+      });
+   }
+
+   prepareData(context, instance) {
+      super.prepareData(context, instance);
+      this.clear();
+      let { data } = instance;
+
+      if (this.onCreateCulture) instance.culture = instance.invoke("onCreateCulture", data, instance);
+      else
+         instance.culture = createCulture({
+            culture: data.culture,
+            numberCulture: data.numberCulture,
+            dateTimeCulture: data.dateTimeCulture,
+            defaultCurrency: data.defaultCurrency,
+            dateEncoding: this.dateEncoding,
+         });
+   }
+
+   explore(context, instance) {
+      let { culture } = instance;
+      pushCulture(culture);
+      if (this.items.length == 0 && this.initialItems) this.add(this.initialItems);
+      super.explore(context, instance);
+   }
+
+   exploreCleanup(context, instance) {
+      popCulture();
+   }
+}
+
+CultureScope.prototype.culture = null;
+CultureScope.prototype.numberCulture = null;
+CultureScope.prototype.dateTimeCulture = null;
+CultureScope.prototype.defaultCurrency = null;
+CultureScope.prototype.dateEncoding = null;

package/src/ui/Format.js

@@ -1,87 +1,107 @@
-import { Culture } from "./Culture";
-import { Format as Fmt, resolveMinMaxFractionDigits } from "../util/Format";
-import { GlobalCacheIdentifier } from "../util/GlobalCacheIdentifier";
-
-export const Format = Fmt;
-
-let cultureSensitiveFormatsRegistered = false;
-
-export function resolveNumberFormattingFlags(flags) {
-   if (!flags) return null;
-   let result = {};
-   if (flags.indexOf("+") >= 0) result.signDisplay = "exceptZero";
-   if (flags.indexOf("c") >= 0) result.notation = "compact";
-   if (flags.indexOf("a") >= 0) result.currencySign = "accounting";
-   return result;
-}
-
-export function enableCultureSensitiveFormatting() {
-   if (cultureSensitiveFormatsRegistered) return;
-
-   cultureSensitiveFormatsRegistered = true;
-
-   Fmt.registerFactory(["number", "n"], (format, minimumFractionDigits, maximumFractionDigits, flags) => {
-      let culture = Culture.getNumberCulture();
-
-      let formatter = culture.getFormatter({
-         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
-         ...resolveNumberFormattingFlags(flags),
-      });
-
-      return (value) => formatter.format(value);
-   });
-
-   Fmt.registerFactory("currency", (format, currency, minimumFractionDigits, maximumFractionDigits, flags) => {
-      let culture = Culture.getNumberCulture();
-      currency = currency || Culture.defaultCurrency;
-
-      let formatter = culture.getFormatter({
-         style: "currency",
-         currency: currency,
-         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
-         ...resolveNumberFormattingFlags(flags),
-      });
-
-      return (value) => formatter.format(value);
-   });
-
-   Fmt.registerFactory(["percentage", "p", "%"], (format, minimumFractionDigits, maximumFractionDigits, flags) => {
-      let culture = Culture.getNumberCulture();
-      let formatter = culture.getFormatter({
-         style: "percent",
-         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
-         ...resolveNumberFormattingFlags(flags),
-      });
-      return (value) => formatter.format(value);
-   });
-
-   Fmt.registerFactory(["percentSign", "ps"], (format, minimumFractionDigits, maximumFractionDigits, flags) => {
-      let culture = Culture.getNumberCulture();
-      let formatter = culture.getFormatter({
-         style: "percent",
-         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
-         ...resolveNumberFormattingFlags(flags),
-      });
-      return (value) => formatter.format(value / 100);
-   });
-
-   Fmt.registerFactory(["date", "d"], (fmt, format = "yyyyMMdd") => {
-      let culture = Culture.getDateTimeCulture();
-      let formatter = culture.getFormatter(format);
-      return (value) => formatter.format(new Date(value));
-   });
-
-   Fmt.registerFactory(["time", "t"], (fmt, format = "hhmmss") => {
-      let culture = Culture.getDateTimeCulture();
-      let formatter = culture.getFormatter(format);
-      return (value) => formatter.format(new Date(value));
-   });
-
-   Fmt.registerFactory(["datetime", "dt"], (fmt, format = "yyyyMd hhmm") => {
-      let culture = Culture.getDateTimeCulture();
-      let formatter = culture.getFormatter(format);
-      return (value) => formatter.format(new Date(value));
-   });
-
-   GlobalCacheIdentifier.change();
-}
+import { Culture, getCurrentCultureCache } from "./Culture";
+import { Format as Fmt, resolveMinMaxFractionDigits, setGetFormatCacheCallback } from "../util/Format";
+import { GlobalCacheIdentifier } from "../util/GlobalCacheIdentifier";
+import { setGetExpressionCacheCallback } from "../data/Expression";
+import { setGetStringTemplateCacheCallback } from "../data/StringTemplate";
+
+export const Format = Fmt;
+
+let cultureSensitiveFormatsRegistered = false;
+
+export function resolveNumberFormattingFlags(flags) {
+   if (!flags) return null;
+   let result = {};
+   if (flags.indexOf("+") >= 0) result.signDisplay = "exceptZero";
+   if (flags.indexOf("c") >= 0) result.notation = "compact";
+   if (flags.indexOf("a") >= 0) result.currencySign = "accounting";
+   return result;
+}
+
+export function enableCultureSensitiveFormatting() {
+   if (cultureSensitiveFormatsRegistered) return;
+
+   cultureSensitiveFormatsRegistered = true;
+
+   Fmt.registerFactory(["number", "n"], (format, minimumFractionDigits, maximumFractionDigits, flags) => {
+      let culture = Culture.getNumberCulture();
+
+      let formatter = culture.getFormatter({
+         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
+         ...resolveNumberFormattingFlags(flags),
+      });
+
+      return (value) => formatter.format(value);
+   });
+
+   Fmt.registerFactory("currency", (format, currency, minimumFractionDigits, maximumFractionDigits, flags) => {
+      let culture = Culture.getNumberCulture();
+      currency = currency || Culture.defaultCurrency;
+
+      let formatter = culture.getFormatter({
+         style: "currency",
+         currency: currency,
+         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
+         ...resolveNumberFormattingFlags(flags),
+      });
+
+      return (value) => formatter.format(value);
+   });
+
+   Fmt.registerFactory(["percentage", "p", "%"], (format, minimumFractionDigits, maximumFractionDigits, flags) => {
+      let culture = Culture.getNumberCulture();
+      let formatter = culture.getFormatter({
+         style: "percent",
+         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
+         ...resolveNumberFormattingFlags(flags),
+      });
+      return (value) => formatter.format(value);
+   });
+
+   Fmt.registerFactory(["percentSign", "ps"], (format, minimumFractionDigits, maximumFractionDigits, flags) => {
+      let culture = Culture.getNumberCulture();
+      let formatter = culture.getFormatter({
+         style: "percent",
+         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
+         ...resolveNumberFormattingFlags(flags),
+      });
+      return (value) => formatter.format(value / 100);
+   });
+
+   Fmt.registerFactory(["date", "d"], (fmt, format = "yyyyMMdd") => {
+      let culture = Culture.getDateTimeCulture();
+      let formatter = culture.getFormatter(format);
+      return (value) => formatter.format(new Date(value));
+   });
+
+   Fmt.registerFactory(["time", "t"], (fmt, format = "hhmmss") => {
+      let culture = Culture.getDateTimeCulture();
+      let formatter = culture.getFormatter(format);
+      return (value) => formatter.format(new Date(value));
+   });
+
+   Fmt.registerFactory(["datetime", "dt"], (fmt, format = "yyyyMd hhmm") => {
+      let culture = Culture.getDateTimeCulture();
+      let formatter = culture.getFormatter(format);
+      return (value) => formatter.format(new Date(value));
+   });
+
+   setGetFormatCacheCallback(() => {
+      let cache = getCurrentCultureCache();
+      if (!cache.formatCache) cache.formatCache = {};
+      return cache.formatCache;
+   });
+
+   setGetExpressionCacheCallback(() => {
+      let cache = getCurrentCultureCache();
+      if (!cache.exprCache) cache.exprCache = {};
+      return cache.exprCache;
+   });
+
+   setGetStringTemplateCacheCallback(() => {
+      let cache = getCurrentCultureCache();
+      if (!cache.strTplCache) cache.strTplCache = {};
+      return cache.strTplCache;
+   });
+
+   GlobalCacheIdentifier.change();
+}