@mux-magic/tools 0.1.0

package/src/logMessage.ts

@@ -0,0 +1,143 @@
+import {
+  type BackgroundColorName,
+  Chalk,
+  type ChalkInstance,
+  type ColorName,
+  type ForegroundColorName,
+} from "chalk"
+
+export const createAddColorToChalk =
+  (chalkColor?: ColorName) =>
+  (chalkInstance: ChalkInstance) =>
+    chalkColor && chalkColor in chalkInstance
+      ? chalkInstance[chalkColor]
+      : chalkInstance
+
+export const messageTemplate = {
+  comparison: (firstItem: string, secondItem: string) =>
+    [firstItem].concat("\n", secondItem),
+  descriptiveComparison: (
+    description: unknown,
+    firstItem: string,
+    secondItem: string,
+  ) =>
+    [description].concat(
+      "\n",
+      "\n",
+      firstItem,
+      "\n",
+      secondItem,
+    ),
+  // Description followed by N items, each separated by a newline. Useful for
+  // download-summary logs and batch-result reports where the caller has a
+  // header line plus a variable-length list of details.
+  multipleItems: (description: string, items: string[]) =>
+    [description].concat(
+      "\n",
+      items.flatMap((item) => [item].concat("\n")),
+    ),
+  noItems: () => [],
+  singleItem: (item: unknown) => [item],
+} as const
+
+const numericalMessageTemplateFallback = {
+  0: messageTemplate.noItems,
+  1: messageTemplate.singleItem,
+  2: messageTemplate.comparison,
+  3: messageTemplate.descriptiveComparison,
+}
+
+export const createLogMessage =
+  <TemplateName extends keyof typeof messageTemplate>({
+    logType,
+    templateName,
+    titleBackgroundColor,
+    titleTextColor,
+  }: {
+    logType: "error" | "info" | "log" | "warn"
+    templateName?: TemplateName
+    titleBackgroundColor?: BackgroundColorName
+    titleTextColor?: ForegroundColorName
+  }) =>
+  (
+    title: string,
+    ...content: Parameters<
+      (typeof messageTemplate)[TemplateName]
+    >
+  ) => {
+    const optionallyColoredChalk = createAddColorToChalk(
+      titleBackgroundColor,
+    )(createAddColorToChalk(titleTextColor)(new Chalk()))
+
+    // Fallback dispatch when no templateName is set: a description string +
+    // an array of items at positions 0 and 1 is the multipleItems shape.
+    // Otherwise pick a template by arity.
+    const message = templateName
+      ? messageTemplate[templateName](
+          // @ts-expect-error A spread argument must either have a tuple type or be passed to a rest parameter.ts(2556)
+          ...content,
+        )
+      : content.at(0) !== undefined &&
+          Array.isArray(content.at(1))
+        ? messageTemplate.multipleItems(
+            // @ts-expect-error A spread argument must either have a tuple type or be passed to a rest parameter.ts(2556)
+            ...content,
+          )
+        : content.length in numericalMessageTemplateFallback
+          ? numericalMessageTemplateFallback[
+              content.length
+            ](
+              // @ts-expect-error A spread argument must either have a tuple type or be passed to a rest parameter.ts(2556)
+              ...content,
+            )
+          : null
+
+    console[logType](
+      optionallyColoredChalk(`[${title}]`),
+      "\n",
+      ...(message || content),
+      // (
+      //   (
+      //     content
+      //     .length
+      //   )
+      //   ? (
+      //     content
+      //     .slice(0, 2)
+      //     .join("\n\n")
+      //   )
+      // ),
+      // ...(
+      //   (
+      //     2 in content
+      //   )
+      //   ? (
+      //     ["\n"]
+      //     .concat(
+      //       content
+      //       .slice(2)
+      //       .join("\n")
+      //     )
+      //   )
+      //   : ""
+      // ),
+      "\n",
+      "\n",
+    )
+  }
+
+export const logError = createLogMessage({
+  logType: "error",
+  titleTextColor: "red",
+})
+
+export const logInfo = createLogMessage({
+  logType: "info",
+  titleTextColor: "green",
+})
+
+export const logWarning = createLogMessage({
+  logType: "warn",
+  titleBackgroundColor: "bgYellowBright",
+  titleTextColor: "black",
+})

package/src/makeDirectory.test.ts

@@ -0,0 +1,71 @@
+import { dirname } from "node:path"
+import { vol } from "memfs"
+import { firstValueFrom } from "rxjs"
+import { beforeEach, describe, expect, test } from "vitest"
+
+import { makeDirectory } from "./makeDirectory.js"
+
+describe(makeDirectory.name, () => {
+  beforeEach(() => {
+    vol.fromJSON({
+      "/movies/Star Wars (1977)/Star Wars (1977).mkv": "",
+    })
+  })
+
+  test("creates the parent directory when caller passes dirname of a file path", async () => {
+    const filePath =
+      "/movies/Super Mario Bros (1993)/Super Mario Bros (1993).mkv"
+
+    await firstValueFrom(makeDirectory(dirname(filePath)))
+
+    await expect(
+      new Promise((resolve, reject) => {
+        vol.readdir(
+          "/movies",
+          (error: unknown, data: unknown) => {
+            if (error) {
+              reject(error)
+            } else {
+              resolve(data)
+            }
+          },
+        )
+      }),
+    ).resolves.toEqual([
+      "Star Wars (1977)",
+      "Super Mario Bros (1993)",
+    ])
+  })
+
+  test("creates the directory itself given a path with no file extension", async () => {
+    const folderPath = "/movies/Super Mario Bros (1993)"
+
+    await firstValueFrom(makeDirectory(folderPath))
+
+    await expect(
+      new Promise((resolve, reject) => {
+        vol.readdir(
+          "/movies",
+          (error: unknown, data: unknown) => {
+            if (error) {
+              reject(error)
+            } else {
+              resolve(data)
+            }
+          },
+        )
+      }),
+    ).resolves.toEqual([
+      "Star Wars (1977)",
+      "Super Mario Bros (1993)",
+    ])
+  })
+
+  test("emits the directory path so callers can chain off of it", async () => {
+    const folderPath = "/movies/Tron (1982)"
+
+    await expect(
+      firstValueFrom(makeDirectory(folderPath)),
+    ).resolves.toBe(folderPath)
+  })
+})

package/src/makeDirectory.ts

@@ -0,0 +1,7 @@
+import { mkdir } from "node:fs/promises"
+import { defer, map } from "rxjs"
+
+export const makeDirectory = (directoryPath: string) =>
+  defer(() =>
+    mkdir(directoryPath, { recursive: true }),
+  ).pipe(map(() => directoryPath))

package/src/naturalSort.ts

@@ -0,0 +1,8 @@
+import { createNewSortInstance } from "fast-sort"
+
+export const naturalSort = createNewSortInstance({
+  comparer: new Intl.Collator(undefined, {
+    numeric: true,
+    sensitivity: "base",
+  }).compare,
+})

package/src/replaceFileExtension.ts

@@ -0,0 +1,9 @@
+import { extname } from "node:path"
+
+export const replaceFileExtension = ({
+  filePath,
+  fileExtension,
+}: {
+  filePath: string
+  fileExtension: string
+}) => filePath.replace(extname(filePath), fileExtension)

package/src/test-runners.ts

@@ -0,0 +1,43 @@
+import {
+  firstValueFrom,
+  type Observable,
+  type Observer,
+  type OperatorFunction,
+  of,
+} from "rxjs"
+import {
+  type RunHelpers,
+  TestScheduler,
+} from "rxjs/testing"
+import { expect } from "vitest"
+
+export const getOperatorValue = <InputValue, OutputValue>(
+  operator: OperatorFunction<InputValue, OutputValue>,
+  ...inputValues: InputValue[]
+) => firstValueFrom(of(...inputValues).pipe(operator))
+
+export const runPromiseScheduler = <ObservableValue>({
+  getSubscriber,
+  observable,
+}: {
+  getSubscriber: (
+    resolve: () => void,
+    reject: () => void,
+  ) => Observer<ObservableValue>
+  observable: Observable<ObservableValue>
+}) =>
+  new Promise<void>((resolve, reject) => {
+    observable.subscribe(getSubscriber(resolve, reject))
+  })
+
+export const runTestScheduler = <ReturnValue>(
+  testRunner: (helpers: RunHelpers) => ReturnValue,
+) => {
+  const testScheduler = new TestScheduler(
+    (actual, expected) => {
+      expect(actual).toEqual(expected)
+    },
+  )
+
+  return testScheduler.run<ReturnValue>(testRunner)
+}