@knocklabs/cli 0.1.13 → 0.1.15

package/dist/{src/lib → lib}/marshal/translation/helpers.js

@@ -104,15 +104,15 @@ const isTranslationDir = (dirPath)=>{
     const locale = _nodepath.basename(dirPath);
     return isValidLocale(locale);
 };
-const buildTranslationFileCtx = async (dirPath, localeCode, namespace)=>{
-    const ref = (0, _processorisomorphic.formatRef)(localeCode, namespace);
-    const filename = (0, _processorisomorphic.formatFileName)(ref);
+const buildTranslationFileCtx = async (dirPath, translationIdentifier, options)=>{
+    const ref = (0, _processorisomorphic.formatRef)(translationIdentifier.localeCode, translationIdentifier.namespace);
+    const filename = (0, _processorisomorphic.formatFileName)(ref, options);
     const abspath = _nodepath.resolve(dirPath, filename);
     const exists = await _fsextra.pathExists(abspath);
     return {
         ref,
-        localeCode,
-        namespace,
+        localeCode: translationIdentifier.localeCode,
+        namespace: translationIdentifier.namespace,
         abspath,
         exists
     };
@@ -182,10 +182,34 @@ const ensureValidCommandTarget = async (props, runContext)=>{
     // Got translationRef arg but no --all flag, which means target only a single
     // translation file.
     if (!flags.all) {
-        const translationFileCtx = await buildTranslationFileCtx(targetDirPath, localeCode, namespace);
+        // If specified, check the given format; otherwise check for all supported formats
+        const formats = flags.format ? [
+            flags.format
+        ] : _processorisomorphic.SUPPORTED_TRANSLATION_FORMATS;
+        const translationFileCtxs = await Promise.all(formats.map(async (format)=>buildTranslationFileCtx(targetDirPath, {
+                localeCode,
+                namespace
+            }, {
+                format
+            })));
+        if (flags.format) {
+            return {
+                type: "translationFile",
+                context: translationFileCtxs[0]
+            };
+        }
+        // If no format is specified, look for the first existing file and return that context
+        const existingFileCtx = translationFileCtxs.find((ctx)=>ctx.exists);
+        if (existingFileCtx) {
+            return {
+                type: "translationFile",
+                context: existingFileCtx
+            };
+        }
+        // If no file exists, fall back to the file context with the default format (json)
         return {
             type: "translationFile",
-            context: translationFileCtx
+            context: translationFileCtxs[0]
         };
     }
     // From this point on, we have both translationRef and --all flag used
@@ -212,7 +236,8 @@ const lsTranslationDir = async (pathToDir)=>{
     return dirents.filter((dirent)=>{
         if (dirent.isDirectory()) return false;
         const filename = dirent.name.toLowerCase();
-        if (!filename.endsWith(`${localeCode}.json`)) return false;
+        const isValidExtension = _processorisomorphic.SUPPORTED_TRANSLATION_FORMATS.some((extension)=>filename.endsWith(`${localeCode}.${extension}`));
+        if (!isValidExtension) return false;
         const { name: translationRef } = _nodepath.parse(filename);
         const parsedRef = parseTranslationRef(translationRef);
         if (!parsedRef) return false;

package/dist/lib/marshal/translation/processor.isomorphic.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    DEFAULT_TRANSLATION_FORMAT: function() {
+        return DEFAULT_TRANSLATION_FORMAT;
+    },
+    SUPPORTED_TRANSLATION_FORMATS: function() {
+        return SUPPORTED_TRANSLATION_FORMATS;
+    },
+    buildTranslationDirBundle: function() {
+        return buildTranslationDirBundle;
+    },
+    formatFileName: function() {
+        return formatFileName;
+    },
+    formatRef: function() {
+        return formatRef;
+    }
+});
+const SUPPORTED_TRANSLATION_FORMATS = [
+    "json",
+    "po"
+];
+const DEFAULT_TRANSLATION_FORMAT = "json";
+const formatRef = (localeCode, namespace)=>namespace ? `${namespace}.${localeCode}` : localeCode;
+const formatFileName = (input, options)=>{
+    var _options_format;
+    const extension = (_options_format = options === null || options === void 0 ? void 0 : options.format) !== null && _options_format !== void 0 ? _options_format : DEFAULT_TRANSLATION_FORMAT;
+    const ref = typeof input === "string" ? input : formatRef(input.locale_code, input.namespace);
+    return `${ref}.${extension}`;
+};
+const buildTranslationDirBundle = (input, options)=>{
+    var _options_format;
+    const format = (_options_format = options === null || options === void 0 ? void 0 : options.format) !== null && _options_format !== void 0 ? _options_format : DEFAULT_TRANSLATION_FORMAT;
+    if (Array.isArray(input)) {
+        const translations = input;
+        return Object.fromEntries(translations.map((translation)=>[
+                formatFileName(translation, {
+                    format
+                }),
+                JSON.parse(translation.content)
+            ]));
+    }
+    const translation = input;
+    const content = format === "json" ? JSON.parse(translation.content) : translation.content;
+    return {
+        [formatFileName(translation, {
+            format
+        })]: content
+    };
+};

package/dist/{src/lib → lib}/marshal/translation/reader.js

@@ -14,6 +14,7 @@ const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
 const _error = require("../../helpers/error");
 const _json = require("../../helpers/json");
 const _helpers = require("./helpers");
+const _processorisomorphic = require("./processor.isomorphic");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -76,10 +77,9 @@ function _interop_require_wildcard(obj, nodeInterop) {
         // push commands. Consider making this an option in the future.
         if (namespace === _helpers.SYSTEM_NAMESPACE) continue;
         // eslint-disable-next-line no-await-in-loop
-        const [content, readJsonErrors] = await (0, _json.readJson)(abspath);
-        if (readJsonErrors.length > 0) {
-            const e = new _error.SourceError((0, _error.formatErrors)(readJsonErrors), abspath);
-            errors.push(e);
+        const [content, sourceError, format] = await readTranslationFile(abspath);
+        if (sourceError) {
+            errors.push(sourceError);
             continue;
         }
         translations.push({
@@ -88,7 +88,8 @@ function _interop_require_wildcard(obj, nodeInterop) {
             namespace,
             abspath,
             exists: true,
-            content: JSON.stringify(content)
+            content,
+            format
         });
     }
     return [
@@ -96,6 +97,56 @@ function _interop_require_wildcard(obj, nodeInterop) {
         errors
     ];
 };
+const readTranslationFile = async (filePath)=>{
+    // Get translation format from file extension
+    const format = getFormatFromFilePath(filePath);
+    switch(format){
+        case "json":
+            {
+                const [jsonContent, readErrors] = await (0, _json.readJson)(filePath);
+                if (readErrors.length > 0) {
+                    const e = new _error.SourceError((0, _error.formatErrors)(readErrors), filePath);
+                    return [
+                        undefined,
+                        e,
+                        format
+                    ];
+                }
+                const content = JSON.stringify(jsonContent);
+                return [
+                    content,
+                    undefined,
+                    format
+                ];
+            }
+        case "po":
+            {
+                try {
+                    const content = await _fsextra.readFile(filePath, "utf8");
+                    return [
+                        content,
+                        undefined,
+                        format
+                    ];
+                } catch (error) {
+                    const e = new _error.SourceError(error.message, filePath);
+                    return [
+                        undefined,
+                        e,
+                        format
+                    ];
+                }
+            }
+        default:
+            throw new Error(`unsupported translation file extension: ${filePath}`);
+    }
+};
+const getFormatFromFilePath = (filePath)=>{
+    // Path.extname returns the extension with a period (e.g. .json)
+    // so we use slice to get just the name
+    const extension = _nodepath.extname(filePath).slice(1);
+    return _processorisomorphic.SUPPORTED_TRANSLATION_FORMATS.includes(extension) ? extension : undefined;
+};
 const readAllForCommandTarget = async (target)=>{
     const { type: targetType, context: targetCtx } = target;
     if (!targetCtx.exists) {

package/dist/{src/lib → lib}/marshal/translation/writer.js

@@ -22,6 +22,7 @@ const _lodash = require("lodash");
 const _const = require("../../helpers/const");
 const _json = require("../../helpers/json");
 const _helpers = require("./helpers");
+const _processorisomorphic = require("./processor.isomorphic");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -63,10 +64,21 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-const writeTranslationFile = async (translationFileCtx, translation)=>_fsextra.outputJson(translationFileCtx.abspath, JSON.parse(translation.content), {
-        spaces: _json.DOUBLE_SPACES
-    });
-const writeTranslationFiles = async (targetDirCtx, translations)=>{
+const writeTranslationFile = async (translationFileCtx, translation, options)=>{
+    var _options_format;
+    const format = (_options_format = options === null || options === void 0 ? void 0 : options.format) !== null && _options_format !== void 0 ? _options_format : _processorisomorphic.DEFAULT_TRANSLATION_FORMAT;
+    switch(format){
+        case "json":
+            return _fsextra.outputJson(translationFileCtx.abspath, JSON.parse(translation.content), {
+                spaces: _json.DOUBLE_SPACES
+            });
+        case "po":
+            return _fsextra.outputFile(translationFileCtx.abspath, translation.content);
+        default:
+            throw new Error(`Invalid translation file format: ${options === null || options === void 0 ? void 0 : options.format}`);
+    }
+};
+const writeTranslationFiles = async (targetDirCtx, translations, options)=>{
     const backupDirPath = _nodepath.resolve(_const.sandboxDir, (0, _lodash.uniqueId)("backup"));
     try {
         // If the index directory already exists, back it up in the temp sandbox
@@ -81,8 +93,11 @@ const writeTranslationFiles = async (targetDirCtx, translations)=>{
             // to write translation files in; otherwise for translations index
             // directory, we want to nest translation files under each locale dir.
             const localeDirPath = "key" in targetDirCtx ? targetDirCtx.abspath : _nodepath.resolve(targetDirCtx.abspath, translation.locale_code);
-            const translationFileCtx = await (0, _helpers.buildTranslationFileCtx)(localeDirPath, translation.locale_code, translation.namespace);
-            return writeTranslationFile(translationFileCtx, translation);
+            const translationFileCtx = await (0, _helpers.buildTranslationFileCtx)(localeDirPath, {
+                localeCode: translation.locale_code,
+                namespace: translation.namespace
+            }, options);
+            return writeTranslationFile(translationFileCtx, translation, options);
         });
         await Promise.all(writeTranslationDirPromises);
     } catch (error) {

package/dist/lib/run-context/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});