@intlify/core-base 10.0.4 → 10.0.6

package/dist/core-base.prod.cjs

@@ -1,6 +1,6 @@
 /*!
-  * core-base v10.0.4
-  * (c) 2024 kazuya kawaguchi
+  * core-base v10.0.6
+  * (c) 2025 kazuya kawaguchi
   * Released under the MIT License.
   */
 'use strict';
@@ -13,10 +13,14 @@ function format(ast) {
     return msg;
 }
 function formatParts(ctx, ast) {
-    const body = ast.b || ast.body;
-    if ((body.t || body.type) === 1 /* NodeTypes.Plural */) {
+    const body = resolveBody(ast);
+    if (body == null) {
+        throw createUnhandleNodeError(0 /* NodeTypes.Resource */);
+    }
+    const type = resolveType(body);
+    if (type === 1 /* NodeTypes.Plural */) {
         const plural = body;
-        const cases = plural.c || plural.cases;
+        const cases = resolveCases(plural);
         return ctx.plural(cases.reduce((messages, c) => [
             ...messages,
             formatMessageParts(ctx, c)
@@ -26,63 +30,132 @@ function formatParts(ctx, ast) {
         return formatMessageParts(ctx, body);
     }
 }
+const PROPS_BODY = ['b', 'body'];
+function resolveBody(node) {
+    return resolveProps(node, PROPS_BODY);
+}
+const PROPS_CASES = ['c', 'cases'];
+function resolveCases(node) {
+    return resolveProps(node, PROPS_CASES, []);
+}
 function formatMessageParts(ctx, node) {
-    const _static = node.s || node.static;
-    if (_static != null) {
+    const static_ = resolveStatic(node);
+    if (static_ != null) {
         return ctx.type === 'text'
-            ? _static
-            : ctx.normalize([_static]);
+            ? static_
+            : ctx.normalize([static_]);
     }
     else {
-        const messages = (node.i || node.items).reduce((acm, c) => [...acm, formatMessagePart(ctx, c)], []);
+        const messages = resolveItems(node).reduce((acm, c) => [...acm, formatMessagePart(ctx, c)], []);
         return ctx.normalize(messages);
     }
 }
+const PROPS_STATIC = ['s', 'static'];
+function resolveStatic(node) {
+    return resolveProps(node, PROPS_STATIC);
+}
+const PROPS_ITEMS = ['i', 'items'];
+function resolveItems(node) {
+    return resolveProps(node, PROPS_ITEMS, []);
+}
 function formatMessagePart(ctx, node) {
-    const type = node.t || node.type;
+    const type = resolveType(node);
     switch (type) {
         case 3 /* NodeTypes.Text */: {
-            const text = node;
-            return (text.v || text.value);
+            return resolveValue$1(node, type);
         }
         case 9 /* NodeTypes.Literal */: {
-            const literal = node;
-            return (literal.v || literal.value);
+            return resolveValue$1(node, type);
         }
         case 4 /* NodeTypes.Named */: {
             const named = node;
-            return ctx.interpolate(ctx.named(named.k || named.key));
+            if (shared.hasOwn(named, 'k') && named.k) {
+                return ctx.interpolate(ctx.named(named.k));
+            }
+            if (shared.hasOwn(named, 'key') && named.key) {
+                return ctx.interpolate(ctx.named(named.key));
+            }
+            throw createUnhandleNodeError(type);
         }
         case 5 /* NodeTypes.List */: {
             const list = node;
-            return ctx.interpolate(ctx.list(list.i != null ? list.i : list.index));
+            if (shared.hasOwn(list, 'i') && shared.isNumber(list.i)) {
+                return ctx.interpolate(ctx.list(list.i));
+            }
+            if (shared.hasOwn(list, 'index') && shared.isNumber(list.index)) {
+                return ctx.interpolate(ctx.list(list.index));
+            }
+            throw createUnhandleNodeError(type);
         }
         case 6 /* NodeTypes.Linked */: {
             const linked = node;
-            const modifier = linked.m || linked.modifier;
-            return ctx.linked(formatMessagePart(ctx, linked.k || linked.key), modifier ? formatMessagePart(ctx, modifier) : undefined, ctx.type);
+            const modifier = resolveLinkedModifier(linked);
+            const key = resolveLinkedKey(linked);
+            return ctx.linked(formatMessagePart(ctx, key), modifier ? formatMessagePart(ctx, modifier) : undefined, ctx.type);
         }
         case 7 /* NodeTypes.LinkedKey */: {
-            const linkedKey = node;
-            return (linkedKey.v || linkedKey.value);
+            return resolveValue$1(node, type);
         }
         case 8 /* NodeTypes.LinkedModifier */: {
-            const linkedModifier = node;
-            return (linkedModifier.v || linkedModifier.value);
+            return resolveValue$1(node, type);
         }
         default:
-            throw new Error(`unhandled node type on format message part: ${type}`);
+            throw new Error(`unhandled node on format message part: ${type}`);
+    }
+}
+const PROPS_TYPE = ['t', 'type'];
+function resolveType(node) {
+    return resolveProps(node, PROPS_TYPE);
+}
+const PROPS_VALUE = ['v', 'value'];
+function resolveValue$1(node, type) {
+    const resolved = resolveProps(node, PROPS_VALUE);
+    if (resolved) {
+        return resolved;
     }
+    else {
+        throw createUnhandleNodeError(type);
+    }
+}
+const PROPS_MODIFIER = ['m', 'modifier'];
+function resolveLinkedModifier(node) {
+    return resolveProps(node, PROPS_MODIFIER);
+}
+const PROPS_KEY = ['k', 'key'];
+function resolveLinkedKey(node) {
+    const resolved = resolveProps(node, PROPS_KEY);
+    if (resolved) {
+        return resolved;
+    }
+    else {
+        throw createUnhandleNodeError(6 /* NodeTypes.Linked */);
+    }
+}
+function resolveProps(node, props, defaultValue) {
+    for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (shared.hasOwn(node, prop) && node[prop] != null) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return node[prop];
+        }
+    }
+    return defaultValue;
+}
+function createUnhandleNodeError(type) {
+    return new Error(`unhandled node type: ${type}`);
 }
 
 const defaultOnCacheKey = (message) => message;
-let compileCache = Object.create(null);
+let compileCache = shared.create();
 function clearCompileCache() {
-    compileCache = Object.create(null);
+    compileCache = shared.create();
+}
+function isMessageAST(val) {
+    return (shared.isObject(val) &&
+        resolveType(val) === 0 &&
+        (shared.hasOwn(val, 'b') || shared.hasOwn(val, 'body')));
 }
-const isMessageAST = (val) => shared.isObject(val) &&
-    (val.t === 0 || val.type === 0) &&
-    ('b' in val || 'body' in val);
 function baseCompile(message, options = {}) {
     // error detecting on compile
     let detectError = false;
@@ -632,7 +705,7 @@ function getWarnMessage(code, ...args) {
  * Intlify core-base version
  * @internal
  */
-const VERSION = '10.0.4';
+const VERSION = '10.0.6';
 const NOT_REOSLVED = -1;
 const DEFAULT_LOCALE = 'en-US';
 const MISSING_RESOLVE_VALUE = '';
@@ -722,17 +795,17 @@ function createCoreContext(options = {}) {
         : _locale;
     const messages = shared.isPlainObject(options.messages)
         ? options.messages
-        : { [_locale]: {} };
+        : createResources(_locale);
     const datetimeFormats = shared.isPlainObject(options.datetimeFormats)
             ? options.datetimeFormats
-            : { [_locale]: {} }
+            : createResources(_locale)
         ;
     const numberFormats = shared.isPlainObject(options.numberFormats)
             ? options.numberFormats
-            : { [_locale]: {} }
+            : createResources(_locale)
         ;
-    const modifiers = shared.assign({}, options.modifiers || {}, getDefaultLinkedModifiers());
-    const pluralRules = options.pluralRules || {};
+    const modifiers = shared.assign(shared.create(), options.modifiers, getDefaultLinkedModifiers());
+    const pluralRules = options.pluralRules || shared.create();
     const missing = shared.isFunction(options.missing) ? options.missing : null;
     const missingWarn = shared.isBoolean(options.missingWarn) || shared.isRegExp(options.missingWarn)
         ? options.missingWarn
@@ -806,6 +879,7 @@ function createCoreContext(options = {}) {
     }
     return context;
 }
+const createResources = (locale) => ({ [locale]: shared.create() });
 /** @internal */
 function isTranslateFallbackWarn(fallback, key) {
     return fallback instanceof RegExp ? fallback.test(key) : fallback;
@@ -925,8 +999,8 @@ const DATETIME_FORMAT_OPTIONS_KEYS = [
 /** @internal */
 function parseDateTimeArgs(...args) {
     const [arg1, arg2, arg3, arg4] = args;
-    const options = {};
-    let overrides = {};
+    const options = shared.create();
+    let overrides = shared.create();
     let value;
     if (shared.isString(arg1)) {
         // Only allow ISO strings - other date formats are often supported,
@@ -1072,8 +1146,8 @@ const NUMBER_FORMAT_OPTIONS_KEYS = [
 /** @internal */
 function parseNumberArgs(...args) {
     const [arg1, arg2, arg3, arg4] = args;
-    const options = {};
-    let overrides = {};
+    const options = shared.create();
+    let overrides = shared.create();
     if (!shared.isNumber(arg1)) {
         throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
     }
@@ -1172,7 +1246,7 @@ function createMessageContext(options = {}) {
     const _list = options.list || [];
     const list = (index) => _list[index];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const _named = options.named || {};
+    const _named = options.named || shared.create();
     shared.isNumber(options.pluralIndex) && normalizeNamed(pluralIndex, _named);
     const named = (key) => _named[key];
     function message(key, useLinked) {
@@ -1239,7 +1313,7 @@ function createMessageContext(options = {}) {
         ["type" /* HelperNameMap.TYPE */]: type,
         ["interpolate" /* HelperNameMap.INTERPOLATE */]: interpolate,
         ["normalize" /* HelperNameMap.NORMALIZE */]: normalize,
-        ["values" /* HelperNameMap.VALUES */]: shared.assign({}, _list, _named)
+        ["values" /* HelperNameMap.VALUES */]: shared.assign(shared.create(), _list, _named)
     };
     return ctx;
 }
@@ -1281,7 +1355,7 @@ function translate(context, ...args) {
         : [
             key,
             locale,
-            messages[locale] || {}
+            messages[locale] || shared.create()
         ];
     // NOTE:
     //  Fix to work around `ssrTransfrom` bug in Vite.
@@ -1346,14 +1420,14 @@ function escapeParams(options) {
 function resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn) {
     const { messages, onWarn, messageResolver: resolveValue, localeFallbacker } = context;
     const locales = localeFallbacker(context, fallbackLocale, locale); // eslint-disable-line @typescript-eslint/no-explicit-any
-    let message = {};
+    let message = shared.create();
     let targetLocale;
     let format = null;
     const type = 'translate';
     for (let i = 0; i < locales.length; i++) {
         targetLocale = locales[i];
         message =
-            messages[targetLocale] || {};
+            messages[targetLocale] || shared.create();
         if ((format = resolveValue(message, key)) === null) {
             // if null, resolve with object key path
             format = message[key]; // eslint-disable-line @typescript-eslint/no-explicit-any
@@ -1398,7 +1472,7 @@ function evaluateMessage(context, msg, msgCtx) {
 /** @internal */
 function parseTranslateArgs(...args) {
     const [arg1, arg2, arg3] = args;
-    const options = {};
+    const options = shared.create();
     if (!shared.isString(arg1) &&
         !shared.isNumber(arg1) &&
         !isMessageFunction(arg1) &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlify/core-base",
-  "version": "10.0.4",
+  "version": "10.0.6",
   "description": "@intlify/core-base",
   "keywords": [
     "core",
@@ -33,11 +33,11 @@
   "jsdelivr": "dist/core-base.global.js",
   "types": "dist/core-base.d.ts",
   "dependencies": {
-    "@intlify/message-compiler": "10.0.4",
-    "@intlify/shared": "10.0.4"
+    "@intlify/message-compiler": "10.0.6",
+    "@intlify/shared": "10.0.6"
   },
   "devDependencies": {
-    "@intlify/devtools-types": "10.0.4"
+    "@intlify/devtools-types": "10.0.6"
   },
   "engines": {
     "node": ">= 16"