@dittowords/cli 4.0.1-alpha.0 → 4.1.0-alpha

package/lib/pull.ts

@@ -25,11 +25,26 @@ import { fetchVariants } from "./http/fetchVariants";
 import { quit } from "./utils/quit";
 import { AxiosError } from "axios";
 import { fetchComponentFolders } from "./http/fetchComponentFolders";
+import { generateSwiftDriver } from "./utils/generateSwiftDriver";
+import { generateIOSBundles } from "./utils/generateIOSBundles";
+
+interface IRequestOptions {
+  projects: Project[];
+  format: SupportedFormat;
+  status: string | undefined;
+  richText?: boolean | undefined;
+  token?: Token;
+  options?: PullOptions;
+}
+
+interface IRequestOptionsWithVariants extends IRequestOptions {
+  variants: { apiID: string }[];
+}
 
 const ensureEndsWithNewLine = (str: string) =>
   str + (/[\r\n]$/.test(str) ? "" : "\n");
 
-const writeFile = (path: string, data: string) =>
+export const writeFile = (path: string, data: string) =>
   new Promise((r) => fs.writeFile(path, ensureEndsWithNewLine(data), r));
 
 const SUPPORTED_FORMATS: SupportedFormat[] = [
@@ -41,7 +56,20 @@ const SUPPORTED_FORMATS: SupportedFormat[] = [
   "icu",
 ];
 
-const JSON_FORMATS: SupportedFormat[] = ["flat", "structured", "icu"];
+export type JSONFormat = "flat" | "nested" | "structured" | "icu";
+
+const IOS_FORMATS: SupportedFormat[] = ["ios-strings", "ios-stringsdict"];
+const JSON_FORMATS: JSONFormat[] = ["flat", "structured", "icu"];
+
+const getJsonFormat = (formats: string[]): JSONFormat => {
+  // edge case: multiple json formats specified
+  // we should grab the last one
+  const jsonFormats = formats.filter((f) =>
+    JSON_FORMATS.includes(f as JSONFormat)
+  ) as JSONFormat[];
+
+  return jsonFormats[jsonFormats.length - 1] || "flat";
+};
 
 const FORMAT_EXTENSIONS = {
   flat: ".json",
@@ -55,7 +83,7 @@ const FORMAT_EXTENSIONS = {
 const getJsonFormatIsValid = (data: string) => {
   try {
     return Object.keys(JSON.parse(data)).some(
-      (k) => !k.startsWith("__variant"),
+      (k) => !k.startsWith("__variant")
     );
   } catch {
     return false;
@@ -73,12 +101,12 @@ export const getFormatDataIsValid = {
 };
 
 const getFormat = (
-  formatFromSource: string | string[] | undefined,
+  formatFromSource: string | string[] | undefined
 ): SupportedFormat[] => {
   const formats = (
     Array.isArray(formatFromSource) ? formatFromSource : [formatFromSource]
   ).filter((format) =>
-    SUPPORTED_FORMATS.includes(format as SupportedFormat),
+    SUPPORTED_FORMATS.includes(format as SupportedFormat)
   ) as SupportedFormat[];
 
   if (formats.length) {
@@ -119,12 +147,9 @@ async function askForAnotherToken() {
  */
 async function downloadAndSaveVariant(
   variantApiId: string | null,
-  projects: Project[],
-  format: SupportedFormat,
-  status: string | undefined,
-  richText: boolean | undefined,
-  token?: Token,
+  requestOptions: IRequestOptions
 ) {
+  const { projects, format, status, richText, token } = requestOptions;
   const api = createApiClient();
   const params: Record<string, string | null> = { variant: variantApiId };
   if (format) params.format = format;
@@ -141,7 +166,7 @@ async function downloadAndSaveVariant(
       if (project.exclude_components)
         projectParams.exclude_components = String(project.exclude_components);
 
-      const { data } = await api.get(`/projects/${project.id}`, {
+      const { data } = await api.get(`/v1/projects/${project.id}`, {
         params: projectParams,
         headers: { Authorization: `token ${token}` },
       });
@@ -153,7 +178,7 @@ async function downloadAndSaveVariant(
       const extension = getFormatExtension(format);
 
       const filename = cleanFileName(
-        project.fileName + ("__" + (variantApiId || "base")) + extension,
+        project.fileName + ("__" + (variantApiId || "base")) + extension
       );
       const filepath = path.join(consts.TEXT_DIR, filename);
 
@@ -169,38 +194,28 @@ async function downloadAndSaveVariant(
 
       await writeFile(filepath, dataString);
       return getSavedMessage(filename);
-    }),
+    })
   );
 
   return savedMessages.join("");
 }
 
 async function downloadAndSaveVariants(
-  variants: { apiID: string }[],
-  projects: Project[],
-  format: SupportedFormat,
-  status: string | undefined,
-  richText: boolean | undefined,
-  token?: Token,
+  requestOptions: IRequestOptionsWithVariants
 ) {
   const messages = await Promise.all([
-    downloadAndSaveVariant(null, projects, format, status, richText, token),
-    ...variants.map(({ apiID }: { apiID: string }) =>
-      downloadAndSaveVariant(apiID, projects, format, status, richText, token),
+    downloadAndSaveVariant(null, requestOptions),
+    ...requestOptions.variants.map(({ apiID }: { apiID: string }) =>
+      downloadAndSaveVariant(apiID, requestOptions)
     ),
   ]);
 
   return messages.join("");
 }
 
-async function downloadAndSaveBase(
-  projects: Project[],
-  format: SupportedFormat,
-  status: string | undefined,
-  richText?: boolean | undefined,
-  token?: Token,
-  options?: PullOptions,
-) {
+async function downloadAndSaveBase(requestOptions: IRequestOptions) {
+  const { projects, format, status, richText, token, options } = requestOptions;
+
   const api = createApiClient();
   const params = { ...options?.meta };
   if (format) params.format = format;
@@ -217,7 +232,7 @@ async function downloadAndSaveBase(
       if (project.exclude_components)
         projectParams.exclude_components = String(project.exclude_components);
 
-      const { data } = await api.get(`/projects/${project.id}`, {
+      const { data } = await api.get(`/v1/projects/${project.id}`, {
         params: projectParams,
         headers: { Authorization: `token ${token}` },
       });
@@ -238,7 +253,7 @@ async function downloadAndSaveBase(
 
       await writeFile(filepath, dataString);
       return getSavedMessage(filename);
-    }),
+    })
   );
 
   return savedMessages.join("");
@@ -253,10 +268,23 @@ function cleanOutputFiles() {
     fs.mkdirSync(consts.TEXT_DIR);
   }
 
-  const fileNames = fs.readdirSync(consts.TEXT_DIR);
-  fileNames.forEach((fileName) => {
-    if (/\.js(on)?|\.xml|\.strings(dict)?$/.test(fileName)) {
-      fs.unlinkSync(path.resolve(consts.TEXT_DIR, fileName));
+  const directoryContents = fs.readdirSync(consts.TEXT_DIR, {
+    withFileTypes: true,
+  });
+
+  directoryContents.forEach((item) => {
+    if (item.isDirectory() && /\.lproj$/.test(item.name)) {
+      return fs.rmSync(path.resolve(consts.TEXT_DIR, item.name), {
+        recursive: true,
+        force: true,
+      });
+    }
+
+    if (
+      item.isFile() &&
+      /\.js(on)?|\.xml|\.strings(dict)?$|\.swift$/.test(item.name)
+    ) {
+      return fs.unlinkSync(path.resolve(consts.TEXT_DIR, item.name));
     }
   });
 
@@ -266,19 +294,9 @@ function cleanOutputFiles() {
 async function downloadAndSave(
   source: SourceInformation,
   token?: Token,
-  options?: PullOptions,
+  options?: PullOptions
 ) {
   const api = createApiClient();
-
-  if (process.env.DEBUG_CLI) {
-    try {
-      await api.get("/health");
-      console.debug("Can connect to api.dittowords.com");
-    } catch {
-      console.debug("CANNOT connect to api.dittowords.com");
-    }
-  }
-
   const {
     validProjects,
     format: formatFromSource,
@@ -287,10 +305,19 @@ async function downloadAndSave(
     richText,
     componentFolders: specifiedComponentFolders,
     componentRoot,
+    localeByVariantApiId,
   } = source;
 
   const formats = getFormat(formatFromSource);
 
+  const hasJSONFormat = formats.some((f) =>
+    JSON_FORMATS.includes(f as JSONFormat)
+  );
+  const hasIOSFormat = formats.some((f) => IOS_FORMATS.includes(f));
+  const shouldGenerateIOSBundles = hasIOSFormat && localeByVariantApiId;
+
+  const shouldLogOutputFiles = !shouldGenerateIOSBundles;
+
   let msg = "";
   const spinner = ora(msg);
   spinner.start();
@@ -301,17 +328,17 @@ async function downloadAndSave(
   ]);
 
   const allComponentFolders = Object.entries(
-    allComponentFoldersResponse,
+    allComponentFoldersResponse
   ).reduce(
     (acc, [id, name]) => acc.concat([{ id, name }]),
-    [] as ComponentFolder[],
+    [] as ComponentFolder[]
   );
 
   try {
     msg += cleanOutputFiles();
     msg += `\nFetching the latest text from ${sourcesToText(
       validProjects,
-      shouldFetchComponentLibrary,
+      shouldFetchComponentLibrary
     )}\n`;
 
     const meta = options ? options.meta : {};
@@ -400,8 +427,8 @@ async function downloadAndSave(
 
             const url =
               componentFolder.id === "__root__"
-                ? "/components?root_only=true"
-                : `/component-folders/${componentFolder.id}/components`;
+                ? "/v1/components?root_only=true"
+                : `/v1/component-folders/${componentFolder.id}/components`;
 
             const { data } = await api.get(url, {
               params: componentFolderParams,
@@ -413,7 +440,7 @@ async function downloadAndSave(
             const namePostfix = `__${variantApiId || "base"}`;
 
             const fileName = cleanFileName(
-              `${nameBase}${nameFolder}${namePostfix}${nameExt}`,
+              `${nameBase}${nameFolder}${namePostfix}${nameExt}`
             );
             const filePath = path.join(consts.TEXT_DIR, fileName);
 
@@ -438,12 +465,14 @@ async function downloadAndSave(
             });
 
             return getSavedMessage(fileName);
-          }),
+          })
         );
       });
 
       const messages = await Promise.all(messagePromises);
-      msg += messages.join("");
+      if (shouldLogOutputFiles) {
+        msg += messages.join("");
+      }
     }
 
     if (shouldFetchComponentLibrary) {
@@ -453,25 +482,32 @@ async function downloadAndSave(
     }
 
     async function fetchProjects(format: SupportedFormat) {
-      msg += variants
-        ? await downloadAndSaveVariants(
-            variants,
-            validProjects,
-            format,
-            status,
-            richText,
-            token,
-          )
-        : await downloadAndSaveBase(
-            validProjects,
-            format,
-            status,
-            richText,
-            token,
-            {
-              meta,
-            },
-          );
+      let result = "";
+      if (variants) {
+        result = await downloadAndSaveVariants({
+          variants,
+          projects: validProjects,
+          format,
+          status,
+          richText,
+          token,
+        });
+      } else {
+        result = await downloadAndSaveBase({
+          projects: validProjects,
+          format,
+          status,
+          richText,
+          token,
+          options: {
+            meta,
+          },
+        });
+      }
+
+      if (shouldLogOutputFiles) {
+        msg += result;
+      }
     }
 
     if (validProjects.length) {
@@ -482,10 +518,15 @@ async function downloadAndSave(
 
     const sources: Source[] = [...validProjects, ...componentSources];
 
-    if (formats.some((f) => JSON_FORMATS.includes(f)))
-      msg += generateJsDriver(sources);
+    if (hasJSONFormat) msg += generateJsDriver(sources, getJsonFormat(formats));
 
-    msg += `\n${output.success("Done")}!`;
+    if (shouldGenerateIOSBundles) {
+      msg += "iOS locale information detected, generating bundles..\n\n";
+      msg += await generateIOSBundles(localeByVariantApiId);
+      msg += await generateSwiftDriver(source);
+    }
+
+    msg += `\n\n${output.success("Done")}!`;
 
     spinner.stop();
     return console.log(msg);
@@ -502,7 +543,7 @@ async function downloadAndSave(
     if (e.response && e.response.status === 401) {
       error = "You don't have access to the selected projects";
       msg = `${output.errorText(error)}.\nChoose others using the ${output.info(
-        "project",
+        "project"
       )} command, or update your API key.`;
       return console.log(msg);
     }
@@ -510,11 +551,11 @@ async function downloadAndSave(
       error =
         "One or more of the requested projects don't have Developer Mode enabled";
       msg = `${output.errorText(
-        error,
+        error
       )}.\nPlease choose different projects using the ${output.info(
-        "project",
+        "project"
       )} command, or turn on Developer Mode for all selected projects. Learn more here: ${output.subtle(
-        "https://www.dittowords.com/docs/ditto-developer-mode",
+        "https://www.dittowords.com/docs/ditto-developer-mode"
       )}.`;
       return console.log(msg);
     }
@@ -522,7 +563,7 @@ async function downloadAndSave(
       error = "projects not found";
     }
     msg = `We hit an error fetching text from the projects: ${output.errorText(
-      error,
+      error
     )}.\nChoose others using the ${output.info("project")} command.`;
     return console.log(msg);
   }
@@ -537,10 +578,6 @@ export const pull = async (options?: PullOptions) => {
   const token = config.getToken(consts.CONFIG_FILE, consts.API_HOST);
   const sourceInformation = config.parseSourceInformation();
 
-  if (process.env.DEBUG_CLI === "true") {
-    console.debug(`Token: ${token}`);
-  }
-
   try {
     return await downloadAndSave(sourceInformation, token, { meta });
   } catch (e) {
@@ -549,15 +586,15 @@ export const pull = async (options?: PullOptions) => {
     if (e instanceof AxiosError) {
       return quit(
         output.errorText(
-          "Something went wrong connecting to Ditto servers. Please contact support or try again later.",
-        ) + eventStr,
+          "Something went wrong connecting to Ditto servers. Please contact support or try again later."
+        ) + eventStr
       );
     }
 
     return quit(
       output.errorText(
-        "Something went wrong. Please contact support or try again later.",
-      ) + eventStr,
+        "Something went wrong. Please contact support or try again later."
+      ) + eventStr
     );
   }
 };

package/lib/types.ts

@@ -46,6 +46,9 @@ export interface ConfigYAML {
   variants?: boolean;
   richText?: boolean;
 
+  // TODO: might want to rename this at some point
+  iosLocales?: Record<string, string>[];
+
   // these are legacy fields - if they exist, we should output
   // a deprecation error, and suggest that they nest them under
   // a top-level `sources` property
@@ -66,6 +69,7 @@ export interface SourceInformation {
   richText: boolean | undefined;
   componentRoot: boolean | { status: string } | undefined;
   componentFolders: ComponentFolder[] | undefined;
+  localeByVariantApiId: Record<string, string> | undefined;
 }
 
 export type Token = string | undefined;

package/lib/utils/determineModuleType.ts

@@ -0,0 +1,57 @@
+import * as fs from "fs";
+import * as path from "path";
+
+export type ModuleType = "commonjs" | "module";
+
+/**
+ * Looks for a `package.json` file starting in the current working directory and traversing upwards
+ * until it finds one or reaches root.
+ * @returns "commonjs" or "module", defaulting to "module" if no `package.json` is found or if the found
+ * file does not include a `type` property.
+ */
+export function determineModuleType() {
+  const value = getRawTypeFromPackageJson();
+  return getTypeOrDefault(value);
+}
+
+function getRawTypeFromPackageJson() {
+  if (process.env.DITTO_MODULE_TYPE) {
+    return process.env.DITTO_MODULE_TYPE;
+  }
+
+  let currentDir: string | null = process.cwd(); // Get the current working directory
+
+  while (currentDir) {
+    const packageJsonPath = path.join(currentDir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      const packageJsonContents = fs.readFileSync(packageJsonPath, "utf8");
+      try {
+        const packageData: { type?: string } = JSON.parse(packageJsonContents);
+        if (packageData?.type) {
+          return packageData.type;
+        }
+      } catch {}
+
+      return null;
+    }
+
+    if (currentDir === "/") {
+      return null;
+    }
+
+    // Move up a directory and continue the search
+    currentDir = path.dirname(currentDir);
+  }
+
+  // No package.json
+  return null;
+}
+
+function getTypeOrDefault(value: string | null): ModuleType {
+  const valueLower = value?.toLowerCase() || "";
+  if (valueLower === "commonjs" || valueLower === "module") {
+    return valueLower;
+  }
+
+  return "commonjs";
+}

package/lib/utils/generateIOSBundles.ts

@@ -0,0 +1,122 @@
+import path from "path";
+import fs from "fs";
+import consts from "../consts";
+import output from "../output";
+
+const IOS_FILE_EXTENSION_PATTERN = /\.(strings|stringsdict)$/;
+
+export async function generateIOSBundles(
+  localeByVariantApiId: Record<string, string> | undefined
+) {
+  const files = fs.readdirSync(consts.TEXT_DIR);
+
+  const bundlesGenerated: {
+    [bundleName: string]: {
+      mappedVariant?: string;
+    };
+  } = {};
+
+  for (const fileName of files) {
+    if (!IOS_FILE_EXTENSION_PATTERN.test(fileName)) {
+      continue;
+    }
+
+    const [name, fileExtension] = fileName.split(".");
+    if (!name.length) {
+      continue;
+    }
+
+    const parts = name.split("__");
+    const source = parts[0];
+    const variant = parts[parts.length - 1];
+    if (!(source && variant)) {
+      continue;
+    }
+
+    const bundleName =
+      localeByVariantApiId && localeByVariantApiId[variant]
+        ? localeByVariantApiId[variant]
+        : variant;
+    const bundleFileName = `${bundleName}.lproj`;
+    const bundleFolder = path.join(consts.TEXT_DIR, bundleFileName);
+    if (!fs.existsSync(bundleFolder)) {
+      fs.mkdirSync(bundleFolder);
+    }
+
+    const filePathCurrent = path.join(consts.TEXT_DIR, fileName);
+    const filePathNew = path.join(bundleFolder, `${source}.${fileExtension}`);
+
+    handleBundleGeneration(source, fileExtension, filePathCurrent, filePathNew);
+
+    bundlesGenerated[bundleFileName] = {
+      mappedVariant: variant === bundleName ? undefined : variant,
+    };
+  }
+
+  return (
+    Object.keys(bundlesGenerated)
+      .map((bundleName) => {
+        let msg = `Successfully generated iOS bundle ${output.info(
+          bundleName
+        )}`;
+        const mappedVariant = bundlesGenerated[bundleName].mappedVariant;
+        if (mappedVariant) {
+          msg += ` ${output.subtle(`(mapped to variant '${mappedVariant}')`)}`;
+        }
+        return msg;
+      })
+      .join("\n") + "\n"
+  );
+}
+
+function handleBundleGeneration(
+  sourceId: string,
+  extension: string,
+  sourcePath: string,
+  newFilePath: string
+) {
+  if (!fs.existsSync(newFilePath)) {
+    return fs.renameSync(sourcePath, newFilePath);
+  }
+
+  if (sourceId !== "components") {
+    throw new Error("Bundle path for " + sourceId + " already exists");
+  }
+
+  if (extension === "strings") {
+    return appendStringsFile(sourcePath, newFilePath);
+  }
+
+  if (extension === "stringsdict") {
+    return appendStringsDictFile(sourcePath, newFilePath);
+  }
+
+  throw new Error("Unsupported extension " + extension);
+}
+
+function appendStringsFile(sourcePath: string, destPath: string) {
+  const sourceContents = fs.readFileSync(sourcePath, "utf-8");
+  const newFileContents = fs.readFileSync(destPath, "utf-8");
+  const newContents = newFileContents + "\n" + sourceContents;
+  fs.writeFileSync(destPath, newContents);
+  fs.unlinkSync(sourcePath);
+}
+
+function appendStringsDictFile(sourcePath: string, destPath: string) {
+  const sourceContentsFull = fs.readFileSync(sourcePath, "utf-8");
+  const sourceContentsContent = sourceContentsFull.split("\n").slice(3, -4);
+
+  const newFileContentsFull = fs.readFileSync(destPath, "utf-8");
+  const newFileContentsContent = newFileContentsFull.split("\n").slice(3, -4);
+
+  const newContents = `<?xml version="1.0" encoding="utf-8"?>
+<plist version="1.0">
+    <dict>
+${[newFileContentsContent, sourceContentsContent].join("\n")}
+    </dict>
+</plist>
+  `;
+
+  fs.writeFileSync(destPath, newContents);
+  fs.unlinkSync(sourcePath);
+}