@platecms/delta-cast-util-to-plaintext 1.4.2 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platecms/delta-cast-util-to-plaintext",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "Utility to convert CAST trees to plaintext.",
   "license": "UNLICENSED",
   "publishConfig": {
@@ -17,12 +17,11 @@
     "src/**/*"
   ],
   "dependencies": {
-    "@platecms/delta-cast": "1.4.2",
-    "@platecms/delta-plate-resource-notation": "1.4.2",
+    "@platecms/delta-cast": "1.5.0",
+    "@platecms/delta-plate-resource-notation": "1.5.0",
     "class-transformer": "0.5.1",
     "reflect-metadata": "0.2.2",
     "tslib": "2.8.1",
-    "zwitch": "2.0.4",
-    "lodash": "4.17.21"
+    "zwitch": "2.0.4"
   }
 }

package/src/lib/index.ts

@@ -17,8 +17,8 @@ import {
   Text,
   Underline,
 } from "@platecms/delta-cast";
-import { isArray } from "lodash";
 import { zwitch } from "zwitch";
+import { isArray } from "./utils";
 
 // default separator for joining nested nodes, avoids the default of joining with a comma
 const separator = " ";

package/src/lib/utils/index.spec.ts

@@ -0,0 +1,160 @@
+import { compact, first, isArray } from "./index";
+
+describe("first", () => {
+  it("should return the first element of an array with numbers", () => {
+    const array = [1, 2, 3, 4, 5];
+    const result = first(array);
+    expect(result).toBe(1);
+  });
+
+  it("should return the first element of an array with strings", () => {
+    const array = ["apple", "banana", "cherry"];
+    const result = first(array);
+    expect(result).toBe("apple");
+  });
+
+  it("should return the first element of an array with objects", () => {
+    const obj1 = { id: 1, name: "first" };
+    const obj2 = { id: 2, name: "second" };
+    const array = [obj1, obj2];
+    const result = first(array);
+    expect(result).toBe(obj1);
+  });
+
+  it("should return undefined for an empty array", () => {
+    const array: number[] = [];
+    const result = first(array);
+    expect(result).toBeUndefined();
+  });
+
+  it("should return the first element even if it's falsy", () => {
+    const array = [0, 1, 2];
+    const result = first(array);
+    expect(result).toBe(0);
+  });
+
+  it("should work with arrays containing undefined", () => {
+    const array = [undefined, "second", "third"];
+    const result = first(array);
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("compact", () => {
+  it("should remove null values from array", () => {
+    const array = [1, null, 2, null, 3];
+    const result = compact(array);
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it("should remove undefined values from array", () => {
+    const array = [1, undefined, 2, undefined, 3];
+    const result = compact(array);
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it("should remove false values from array", () => {
+    const array = [true, false, true, false];
+    const result = compact(array);
+    expect(result).toEqual([true, true]);
+  });
+
+  it("should remove empty strings from array", () => {
+    const array = ["hello", "", "world", ""];
+    const result = compact(array);
+    expect(result).toEqual(["hello", "world"]);
+  });
+
+  it("should remove zero values from array", () => {
+    const array = [1, 0, 2, 0, 3];
+    const result = compact(array);
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it("should remove all falsy values in mixed array", () => {
+    const array = [1, null, "hello", undefined, false, "", 0, 2, "world"];
+    const result = compact(array);
+    expect(result).toEqual([1, "hello", 2, "world"]);
+  });
+
+  it("should return empty array when all values are falsy", () => {
+    const array = [null, undefined, false, "", 0];
+    const result = compact(array);
+    expect(result).toEqual([]);
+  });
+
+  it("should return same array when no falsy values", () => {
+    const array = [1, 2, "hello", true, { id: 1 }];
+    const result = compact(array);
+    expect(result).toEqual([1, 2, "hello", true, { id: 1 }]);
+  });
+
+  it("should work with empty array", () => {
+    const array: (string | null)[] = [];
+    const result = compact(array);
+    expect(result).toEqual([]);
+  });
+});
+
+describe("isArray", () => {
+  it("should return true for empty array", () => {
+    const value: unknown = [];
+    expect(isArray(value)).toBe(true);
+  });
+
+  it("should return true for array of numbers", () => {
+    const value: unknown = [1, 2, 3];
+    expect(isArray(value)).toBe(true);
+  });
+
+  it("should return true for array of strings", () => {
+    const value: unknown = ["a", "b", "c"];
+    expect(isArray(value)).toBe(true);
+  });
+
+  it("should return true for array of objects", () => {
+    const value: unknown = [{ id: 1 }, { id: 2 }];
+    expect(isArray(value)).toBe(true);
+  });
+
+  it("should return false for null", () => {
+    const value: unknown = null;
+    expect(isArray(value)).toBe(false);
+  });
+
+  it("should return false for undefined", () => {
+    const value: unknown = undefined;
+    expect(isArray(value)).toBe(false);
+  });
+
+  it("should return false for plain object", () => {
+    const value: unknown = { key: "value" };
+    expect(isArray(value)).toBe(false);
+  });
+
+  it("should return false for string", () => {
+    const value: unknown = "hello";
+    expect(isArray(value)).toBe(false);
+  });
+
+  it("should return false for number", () => {
+    const value: unknown = 42;
+    expect(isArray(value)).toBe(false);
+  });
+
+  it("should return false for boolean", () => {
+    const value: unknown = true;
+    expect(isArray(value)).toBe(false);
+  });
+
+  it("should return false for function", () => {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    function value(): void {}
+    expect(isArray(value)).toBe(false);
+  });
+
+  it("should return false for Date object", () => {
+    const value: unknown = new Date();
+    expect(isArray(value)).toBe(false);
+  });
+});

package/src/lib/utils/index.ts

@@ -0,0 +1,11 @@
+export function first<T>(array: T[]): T | undefined {
+  return array[0];
+}
+
+export function compact<T>(array: (T | "" | 0 | false | null | undefined)[]): T[] {
+  return array.filter((value) => Boolean(value)) as T[];
+}
+
+export function isArray<T>(value: unknown): value is T[] {
+  return Array.isArray(value);
+}