cx 24.3.8 → 24.3.10

package/src/data/StringTemplate.js

@@ -1,85 +1,92 @@
-import { expression } from "./Expression";
-
-import { quoteStr } from "../util/quote";
-
-function plus(str) {
-   return str.length ? str + " + " : str;
-}
-
-let tplCache = {};
-
-export function stringTemplate(str) {
-   let expr = tplCache[str];
-   if (expr) return expr;
-
-   expr = "";
-
-   let termStart = -1,
-      quoteStart = 0,
-      term,
-      bracketsOpen = 0,
-      percentSign;
-
-   for (let i = 0; i < str.length; i++) {
-      let c = str[i];
-      switch (c) {
-         case "{":
-            if (termStart < 0) {
-               if (str[i + 1] == "{" && str[i - 1] != "%") {
-                  expr = plus(expr) + quoteStr(str.substring(quoteStart, i) + "{");
-                  i++;
-                  quoteStart = i + 1;
-               } else {
-                  termStart = i + 1;
-                  percentSign = str[i - 1] == "%";
-                  if (i > quoteStart) expr = plus(expr) + quoteStr(str.substring(quoteStart, percentSign ? i - 1 : i));
-                  bracketsOpen = 1;
-               }
-            } else bracketsOpen++;
-            break;
-
-         case "}":
-            if (termStart >= 0) {
-               if (--bracketsOpen == 0) {
-                  term = str.substring(termStart, i);
-                  if (term.indexOf(":") == -1) {
-                     let nullSepIndex = term.indexOf("|");
-                     if (nullSepIndex == -1) term += ":s";
-                     else term = term.substring(0, nullSepIndex) + ":s" + term.substring(nullSepIndex);
-                  }
-                  expr = plus(expr) + (percentSign ? "%{" : "{") + term + "}";
-                  termStart = -1;
-                  quoteStart = i + 1;
-                  bracketsOpen = 0;
-               }
-            } else if (str[i + 1] == "}") {
-               expr = plus(expr) + quoteStr(str.substring(quoteStart, i) + "}");
-               i++;
-               quoteStart = i + 1;
-            }
-            break;
-      }
-   }
-
-   if (quoteStart < str.length) expr = plus(expr) + quoteStr(str.substring(quoteStart));
-
-   return (tplCache[str] = expression(expr));
-}
-
-export const StringTemplate = {
-   get: function (str) {
-      return stringTemplate(str);
-   },
-
-   compile: function (str) {
-      return stringTemplate(str).memoize();
-   },
-
-   format: function (format, ...args) {
-      return stringTemplate(format)(args);
-   },
-};
-
-export function invalidateStringTemplateCache() {
-   tplCache = {};
-}
+import { expression } from "./Expression";
+
+import { quoteStr } from "../util/quote";
+
+function plus(str) {
+   return str.length ? str + " + " : str;
+}
+
+export function stringTemplate(str) {
+   let tplCache = getTplCache();
+   let expr = tplCache[str];
+   if (expr) return expr;
+
+   expr = "";
+
+   let termStart = -1,
+      quoteStart = 0,
+      term,
+      bracketsOpen = 0,
+      percentSign;
+
+   for (let i = 0; i < str.length; i++) {
+      let c = str[i];
+      switch (c) {
+         case "{":
+            if (termStart < 0) {
+               if (str[i + 1] == "{" && str[i - 1] != "%") {
+                  expr = plus(expr) + quoteStr(str.substring(quoteStart, i) + "{");
+                  i++;
+                  quoteStart = i + 1;
+               } else {
+                  termStart = i + 1;
+                  percentSign = str[i - 1] == "%";
+                  if (i > quoteStart) expr = plus(expr) + quoteStr(str.substring(quoteStart, percentSign ? i - 1 : i));
+                  bracketsOpen = 1;
+               }
+            } else bracketsOpen++;
+            break;
+
+         case "}":
+            if (termStart >= 0) {
+               if (--bracketsOpen == 0) {
+                  term = str.substring(termStart, i);
+                  if (term.indexOf(":") == -1) {
+                     let nullSepIndex = term.indexOf("|");
+                     if (nullSepIndex == -1) term += ":s";
+                     else term = term.substring(0, nullSepIndex) + ":s" + term.substring(nullSepIndex);
+                  }
+                  expr = plus(expr) + (percentSign ? "%{" : "{") + term + "}";
+                  termStart = -1;
+                  quoteStart = i + 1;
+                  bracketsOpen = 0;
+               }
+            } else if (str[i + 1] == "}") {
+               expr = plus(expr) + quoteStr(str.substring(quoteStart, i) + "}");
+               i++;
+               quoteStart = i + 1;
+            }
+            break;
+      }
+   }
+
+   if (quoteStart < str.length) expr = plus(expr) + quoteStr(str.substring(quoteStart));
+
+   return (tplCache[str] = expression(expr));
+}
+
+export const StringTemplate = {
+   get: function (str) {
+      return stringTemplate(str);
+   },
+
+   compile: function (str) {
+      return stringTemplate(str).memoize();
+   },
+
+   format: function (format, ...args) {
+      return stringTemplate(format)(args);
+   },
+};
+
+let tplCache = {};
+
+let getTplCache = () => tplCache;
+
+export function invalidateStringTemplateCache() {
+   tplCache = {};
+}
+
+export function setGetStringTemplateCacheCallback(callback) {
+   getTplCache = callback;
+}

package/src/ui/Culture.d.ts

@@ -1,23 +1,47 @@
-declare type DateEncoding = (date: Date) => any;
-
-export class Culture {
-   static setCulture(cultureCode: string): void;
-
-   static setDefaultCurrency(currencyCode: string): void;
-
-   static readonly defaultCurrency: string;
-
-   static readonly culture: string;
-
-   static setNumberCulture(cultureCode: string): void;
-
-   static getNumberCulture(): any;
-
-   static setDateTimeCulture(cultureCode: string): void;
-
-   static getDateTimeCulture(): any;
-
-   static getDefaultDateEncoding(): DateEncoding;
-
-   static setDefaultDateEncoding(encoding: DateEncoding): void;
-}
+declare type DateEncoding = (date: Date) => any;
+
+export class Culture {
+   static setCulture(cultureCode: string): void;
+
+   static setDefaultCurrency(currencyCode: string): void;
+
+   static readonly defaultCurrency: string;
+
+   static readonly culture: string;
+
+   static setNumberCulture(cultureCode: string): void;
+
+   static getNumberCulture(): any;
+
+   static setDateTimeCulture(cultureCode: string): void;
+
+   static getDateTimeCulture(): any;
+
+   static getDefaultDateEncoding(): DateEncoding;
+
+   static setDefaultDateEncoding(encoding: DateEncoding): void;
+}
+
+export interface CultureSpecs {
+   culture?: string;
+   numberCulture?: string;
+   dateCulture?: string;
+   defaultCurrency?: string;
+   dateEncoding?: DateEncoding;
+}
+
+export interface CultureInfo {
+   culture: string;
+   numberCulture?: string;
+   dateCulture?: string;
+   defaultCurrency: string;
+   dateEncoding: DateEncoding;
+}
+
+export function createCulture(cultureSpecs: CultureSpecs): CultureInfo;
+
+export function pushCulture(cultureSpecs: CultureInfo): void;
+
+export function popCulture(): CultureInfo;
+
+export function getCurrentCultureCache(): any;

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,55 @@
+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);
+      context.push("cultureInfo", culture);
+      super.explore(context, instance);
+   }
+
+   exploreCleanup(context, instance) {
+      context.pop("cultureInfo");
+      popCulture();
+   }
+}
+
+CultureScope.prototype.culture = null;
+CultureScope.prototype.numberCulture = null;
+CultureScope.prototype.dateTimeCulture = null;
+CultureScope.prototype.defaultCurrency = null;
+CultureScope.prototype.dateEncoding = null;