@dittowords/cli 4.5.2 → 5.0.0-beta.0

package/lib/replace.test.ts

@@ -1,157 +0,0 @@
-import fs from "fs";
-import { parseOptions, replaceJSXTextInFile } from "./replace"; // Assuming the function is exported in a separate file
-
-jest.mock("fs");
-
-// Helper function to create a temporary file
-async function createTempJSXFile(content: string): Promise<string> {
-  const tempFile = "/tempFile.jsx";
-  await new Promise((resolve, reject) => {
-    try {
-      fs.writeFile(tempFile, content, resolve);
-    } catch (e) {
-      reject(e);
-    }
-  });
-  return tempFile;
-}
-
-// Helper function to delete the temporary file
-async function deleteTempFile(filePath: string): Promise<void> {
-  await new Promise((resolve, reject) => {
-    try {
-      fs.unlink(filePath, resolve);
-    } catch (e) {
-      reject(e);
-    }
-  });
-}
-
-describe("parseOptions", () => {
-  test("should pass with valid input", async () => {
-    const tempFile = await createTempJSXFile("<div>Hello, world!</div>");
-    expect(() =>
-      parseOptions([tempFile, "secondString", "thirdString"])
-    ).not.toThrow();
-
-    const result = parseOptions([tempFile, "secondString", "thirdString"]);
-    expect(result).toEqual({
-      filePath: tempFile,
-      searchString: "secondString",
-      replaceWith: "thirdString",
-    });
-
-    deleteTempFile(tempFile);
-  });
-
-  test("should throw error when options array does not have exactly three strings", () => {
-    expect(() => parseOptions(["oneString"])).toThrow(
-      "The options array must contain <file path> <search string> <replace with>."
-    );
-    expect(() => parseOptions(["one", "two"])).toThrow(
-      "The options array must contain <file path> <search string> <replace with>."
-    );
-    expect(() => parseOptions(["one", "two", "three", "four"])).toThrow(
-      "The options array must contain <file path> <search string> <replace with>."
-    );
-  });
-
-  test("should throw error when the first string is not a valid file path", () => {
-    const invalidFilePath = "/path/to/invalid/file.txt";
-    expect(() =>
-      parseOptions([invalidFilePath, "secondString", "thirdString"])
-    ).toThrow(`${invalidFilePath} is not a valid file path.`);
-  });
-
-  test("should throw error when the first string is a directory", () => {
-    const directoryPath = ".";
-    expect(() =>
-      parseOptions([directoryPath, "secondString", "thirdString"])
-    ).toThrow(`${directoryPath} is not a valid file path.`);
-  });
-});
-
-describe("replaceJSXTextInFile", () => {
-  afterEach(async () => {
-    await deleteTempFile("/tempFile.jsx");
-  });
-
-  test("should replace JSX text with a DittoComponent", async () => {
-    const tempFile = await createTempJSXFile("<div>Hello, world</div>");
-    const searchString = "world";
-    const replaceWith = "some-id";
-
-    await replaceJSXTextInFile(tempFile, { searchString, replaceWith }, {});
-
-    const transformedCode = await new Promise((resolve, reject) => {
-      fs.readFile(tempFile, "utf-8", (error, data) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve(data);
-        }
-      });
-    });
-    expect(transformedCode).toContain(
-      `<div>Hello, <DittoComponent componentId="${replaceWith}" /></div>`
-    );
-  });
-
-  test("should replace JSX text with a DittoComponent with a flag", async () => {
-    const tempFile = await createTempJSXFile(
-      `<>\n<div>Hello, world</div>\n<div>Hello, world</div>\n</>`
-    );
-    const searchString = "world";
-    const replaceWith = "some-id";
-
-    await replaceJSXTextInFile(
-      tempFile,
-      { searchString, replaceWith },
-      { lineNumbers: [3] }
-    );
-
-    const transformedCode = await new Promise((resolve, reject) =>
-      fs.readFile(tempFile, "utf-8", (error, data) => {
-        if (error) reject(error);
-        else resolve(data);
-      })
-    );
-    expect(transformedCode).toContain(
-      `<>\n  <div>Hello, world</div>\n  <div>Hello, <DittoComponent componentId=\"some-id\" /></div>\n</>;`
-    );
-  });
-
-  test("should handle case-insensitive search", async () => {
-    const tempFile = await createTempJSXFile("<div>HeLLo, WoRlD</div>");
-    const searchString = "world";
-    const replaceWith = "some-id";
-
-    await replaceJSXTextInFile(tempFile, { searchString, replaceWith }, {});
-
-    const transformedCode = await new Promise((resolve, reject) =>
-      fs.readFile(tempFile, "utf-8", (error, data) => {
-        if (error) reject(error);
-        else resolve(data);
-      })
-    );
-    expect(transformedCode).toContain(
-      `<div>HeLLo, <DittoComponent componentId="${replaceWith}" /></div>`
-    );
-  });
-
-  test("should not replace JSX text if searchString is not found", async () => {
-    const tempFile = await createTempJSXFile("<div>Hello, world!</div>");
-    const searchString = "foobar";
-    const replaceWith = "some-id";
-
-    await replaceJSXTextInFile(tempFile, { searchString, replaceWith }, {});
-
-    const transformedCode = await new Promise((resolve, reject) =>
-      fs.readFile(tempFile, "utf-8", (error, data) => {
-        if (error) reject(error);
-        else resolve(data);
-      })
-    );
-    expect(transformedCode).toContain("<div>Hello, world!</div>");
-  });
-});

package/lib/replace.ts

@@ -1,140 +0,0 @@
-import fs from "fs";
-import { parse } from "@babel/parser";
-import traverse from "@babel/traverse";
-import * as t from "@babel/types";
-import { transformFromAst } from "@babel/core";
-
-async function replaceJSXTextInFile(
-  filePath: string,
-  replacement: { searchString: string; replaceWith: string },
-  flags: {
-    lineNumbers?: number[];
-  }
-) {
-  const code = await new Promise<string>((resolve, reject) =>
-    fs.readFile(filePath, "utf-8", (err, data) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(data);
-      }
-    })
-  );
-  const ast = parse(code, {
-    sourceType: "module",
-    plugins: ["jsx", "typescript"],
-  });
-
-  traverse(ast, {
-    JSXText(path) {
-      const { searchString, replaceWith } = replacement;
-
-      const searchStringEscaped = searchString.replace(
-        /[.*+?^${}()|[\]\\]/g,
-        "\\$&"
-      );
-      const regex = new RegExp(searchStringEscaped, "gi");
-      if (regex.test(path.node.value)) {
-        // Ignore if not on a line number that we want to replace.
-        if (
-          flags.lineNumbers &&
-          path.node.loc &&
-          !flags.lineNumbers.includes(path.node.loc.start.line)
-        ) {
-          return;
-        }
-
-        const splitValues = splitByCaseInsensitive(
-          path.node.value,
-          searchStringEscaped
-        );
-        const nodes: (t.JSXElement | t.JSXText)[] = [];
-
-        splitValues.forEach((splitValue) => {
-          if (splitValue.toLowerCase() === searchString.toLowerCase()) {
-            const identifier = t.jsxIdentifier("DittoComponent");
-            const componentId = t.jsxAttribute(
-              t.jsxIdentifier("componentId"),
-              t.stringLiteral(replaceWith)
-            );
-            const o = t.jsxOpeningElement(identifier, [componentId], true);
-            const jsxElement = t.jsxElement(o, undefined, [], true);
-            nodes.push(jsxElement);
-          } else {
-            nodes.push(t.jsxText(splitValue));
-          }
-        });
-
-        path.replaceWithMultiple(nodes);
-      }
-    },
-  });
-
-  // transfromFromAst types are wrong?
-  /* @ts-ignore */
-  const { code: transformedCode } = transformFromAst(ast, code, {
-    // Don't let this codebase's Babel config affect the code we're transforming.
-    /* @ts-ignore */
-    configFile: false,
-  });
-
-  await new Promise((resolve, reject) =>
-    fs.writeFile(filePath, transformedCode, (err) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(null);
-      }
-    })
-  );
-}
-
-function splitByCaseInsensitive(str: string, delimiter: string) {
-  return str.split(new RegExp(`(${delimiter})`, "gi")).filter((s) => s !== "");
-}
-
-function replace(options: string[], flags: { lineNumbers?: number[] }) {
-  let filePath: string;
-  let searchString: string;
-  let replaceWith: string;
-
-  try {
-    const parsedOptions = parseOptions(options);
-    filePath = parsedOptions.filePath;
-    searchString = parsedOptions.searchString;
-    replaceWith = parsedOptions.replaceWith;
-  } catch (e) {
-    console.error(e);
-    console.error(
-      "Usage for replace: ditto-cli replace <file path> <search string> <replace with>"
-    );
-    return;
-  }
-
-  replaceJSXTextInFile(filePath, { searchString, replaceWith }, flags);
-}
-
-function parseOptions(options: string[]): {
-  filePath: string;
-  searchString: string;
-  replaceWith: string;
-} {
-  if (options.length !== 3) {
-    throw new Error(
-      "The options array must contain <file path> <search string> <replace with>."
-    );
-  }
-
-  const filePath = options[0];
-  // Check if the file path exists and points to a regular file (not a directory or other file system object).
-  const isFilePathValid =
-    fs.existsSync(filePath) && fs.lstatSync(filePath).isFile();
-
-  if (!isFilePathValid) {
-    throw new Error(`${filePath} is not a valid file path.`);
-  }
-
-  return { filePath, searchString: options[1], replaceWith: options[2] };
-}
-
-export { replace, parseOptions, replaceJSXTextInFile };

package/lib/types.ts

@@ -1,83 +0,0 @@
-export interface Project {
-  name: string;
-  id: string;
-  url?: string;
-  fileName?: string;
-  status?: string;
-  exclude_components?: boolean;
-}
-
-export type ComponentSource = ComponentFolder & {
-  type: "components";
-  fileName: string;
-  variant: string;
-};
-
-export type Source = (Project & { type?: undefined }) | ComponentSource;
-
-export interface ComponentFolder {
-  id: string;
-  name: string;
-  status?: string;
-}
-
-export type SupportedFormat =
-  | "flat"
-  | "nested"
-  | "structured"
-  | "android"
-  | "ios-strings"
-  | "ios-stringsdict"
-  | "icu";
-
-export type SupportedExtension = ".json" | ".xml" | ".strings" | ".stringsdict";
-
-type ComponentsSourceBool = boolean;
-type ComponentsSourceConfig = {
-  root?: boolean | { status: string };
-  folders?: ComponentFolder[];
-};
-type ComponentsSource = ComponentsSourceBool | ComponentsSourceConfig;
-
-export interface ConfigYAML {
-  sources?: {
-    components?: ComponentsSource;
-    projects?: Project[];
-  };
-  format?: SupportedFormat;
-  status?: string;
-  variants?: boolean;
-  richText?: boolean;
-
-  // TODO: might want to rename this at some point
-  iosLocales?: Record<string, string>[];
-
-  // prevents the generation of index.js and index.d.ts files
-  // when working with JSON formats
-  disableJsDriver?: boolean;
-
-  // 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
-  components?: boolean;
-  projects?: Project[];
-}
-
-export interface SourceInformation {
-  hasSourceData: boolean;
-  hasTopLevelProjectsField: boolean;
-  hasTopLevelComponentsField: boolean;
-  hasComponentLibraryInProjects: boolean;
-  validProjects: Project[];
-  shouldFetchComponentLibrary: boolean;
-  variants: boolean;
-  format: string | string[] | undefined;
-  status: string | undefined;
-  richText: boolean | undefined;
-  componentRoot: boolean | { status: string } | undefined;
-  componentFolders: ComponentFolder[] | undefined;
-  localeByVariantApiId: Record<string, string> | undefined;
-  disableJsDriver?: boolean;
-}
-
-export type Token = string | undefined;

package/lib/utils/cleanFileName.test.ts

@@ -1,11 +0,0 @@
-import { cleanFileName } from "./cleanFileName";
-
-describe("cleanFileName tests", () => {
-  it("correctly cleans emojis", () => {
-    const folderName = "👍Good Folder";
-    expect(cleanFileName(folderName)).toEqual("good-folder");
-
-    const fileName = "👍 Good Folder";
-    expect(cleanFileName(fileName)).toEqual("good-folder");
-  });
-});

package/lib/utils/cleanFileName.ts

@@ -1,8 +0,0 @@
-export function cleanFileName(fileName: string): string {
-  let parts = fileName.split(/\s{1,}/g);
-  parts = parts.map((part) =>
-    part.replace(/[^a-zA-Z0-9-_.]/g, "").toLowerCase()
-  );
-  parts = parts.filter((part) => part !== "");
-  return parts.join("-");
-}

package/lib/utils/createSentryContext.ts

@@ -1,20 +0,0 @@
-type SentryContext = Record<
-  string,
-  string | number | boolean | null | undefined
->;
-
-/**
- * Sentry context only supports properties one layer deep
- */
-export function createSentryContext(obj: unknown) {
-  if (typeof obj !== "object") return {};
-
-  const ctx: SentryContext = {};
-  for (const key in obj) {
-    const k = key as keyof typeof obj;
-    const r = obj[k];
-    ctx[k] = typeof r === "object" || Array.isArray(r) ? JSON.stringify(r) : r;
-  }
-
-  return ctx;
-}

package/lib/utils/determineModuleType.test.ts

@@ -1,48 +0,0 @@
-import { determineModuleType } from "./determineModuleType";
-import { vol } from "memfs";
-
-const defaultEnv = process.env;
-
-jest.mock("fs");
-
-beforeEach(() => {
-  vol.reset();
-  process.env = { ...defaultEnv };
-});
-
-test("'commonjs' if no package.json found", () => {
-  expect(determineModuleType()).toBe("commonjs");
-});
-
-test("'commonjs' if package.json found but no `type` property", () => {
-  vol.fromJSON({ "package.json": JSON.stringify({}) }, process.cwd());
-  expect(determineModuleType()).toBe("commonjs");
-});
-
-test("'commonjs' if package.json found and `type` property is 'commonjs'", () => {
-  vol.fromJSON({ "package.json": JSON.stringify({ type: "commonjs" }) });
-  expect(determineModuleType()).toBe("commonjs");
-});
-
-test("'commonjs' if package.json found and `type` property is invalid", () => {
-  vol.fromJSON({ "package.json": JSON.stringify({ type: "invalid-type" }) });
-  expect(determineModuleType()).toBe("commonjs");
-});
-
-test("'module' if package.json found and `type` property is 'module'", () => {
-  vol.fromJSON({ "package.json": JSON.stringify({ type: "module" }) });
-  expect(determineModuleType()).toBe("module");
-});
-
-test("finds package.json in parent directories", () => {
-  vol.fromJSON({
-    "/some/nested/dir/test.txt": "",
-    "/package.json": JSON.stringify({ type: "module" }),
-  });
-  expect(determineModuleType("/some/nested/dir")).toBe("module");
-});
-
-test("supports explicit specification of module type via environment variable", () => {
-  process.env.DITTO_MODULE_TYPE = "module";
-  expect(determineModuleType()).toBe("module");
-});

package/lib/utils/determineModuleType.ts

@@ -1,55 +0,0 @@
-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(currentDir: string | null = process.cwd()) {
-  const value = getRawTypeFromPackageJson(currentDir);
-  return getTypeOrDefault(value);
-}
-
-function getRawTypeFromPackageJson(currentDir: string | null) {
-  if (process.env.DITTO_MODULE_TYPE) {
-    return process.env.DITTO_MODULE_TYPE;
-  }
-
-  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 === "/") {
-      break;
-    }
-
-    // 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

@@ -1,122 +0,0 @@
-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);
-}