@dittowords/cli 4.0.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",
@@ -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}` },
       });
@@ -176,31 +201,21 @@ async function downloadAndSaveVariant(
 }
 
 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}` },
       });
@@ -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));
     }
   });
 
@@ -277,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();
@@ -390,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,
@@ -433,7 +470,9 @@ async function downloadAndSave(
       });
 
       const messages = await Promise.all(messagePromises);
-      msg += messages.join("");
+      if (shouldLogOutputFiles) {
+        msg += messages.join("");
+      }
     }
 
     if (shouldFetchComponentLibrary) {
@@ -443,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) {
@@ -472,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));
+
+    if (shouldGenerateIOSBundles) {
+      msg += "iOS locale information detected, generating bundles..\n\n";
+      msg += await generateIOSBundles(localeByVariantApiId);
+      msg += await generateSwiftDriver(source);
+    }
 
-    msg += `\n${output.success("Done")}!`;
+    msg += `\n\n${output.success("Done")}!`;
 
     spinner.stop();
     return console.log(msg);

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);
+}