@platecms/delta-client 0.11.0 → 0.11.1

package/README.md

@@ -282,7 +282,9 @@ const blogPostSchema = schema.contentItem({
     name: schema.string(),
     avatar: schema.asset(),
   }),
-  tags: schema.array(schema.tag()),
+  tags: schema.array(schema.tag()).placeholder({
+    minLength: 1
+  }),
   publishedAt: schema.date(),
   featured: schema.boolean().placeholder(false),
 });
@@ -324,7 +326,6 @@ const MyEditor = () => {
 - `@platecms/delta-cast` - Core casting utilities
 - `@graphql-typed-document-node/core` - GraphQL type safety
 - `graphql` - GraphQL implementation
-- `lodash` - Utility functions
 - `slate` - Rich text editor framework
 - `slate-react` - React integration for Slate
 - `tslib` - TypeScript runtime library

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platecms/delta-client",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "Utilities and functions to interact with the Delta CMS.",
   "license": "UNLICENSED",
   "publishConfig": {
@@ -18,17 +18,17 @@
     "src/**/*"
   ],
   "peerDependencies": {
-    "@platecms/delta-cast": "0.11.0",
+    "@platecms/delta-cast": "0.11.1",
     "@graphql-typed-document-node/core": "3.2.0",
     "graphql": "16.11.0",
-    "lodash": "4.17.21",
     "slate": "0.118.0",
     "slate-react": "0.117.4",
     "tslib": "2.8.1",
     "class-transformer": "0.5.1",
     "reflect-metadata": "0.2.2",
     "@apollo/client": "3.13.9",
-    "defu": "6.1.4"
+    "defu": "6.1.4",
+    "lodash": "4.17.21"
   },
   "exports": {
     "./package.json": "./package.json",

package/src/apollo/index.ts

@@ -9,7 +9,6 @@ import {
   from,
 } from "@apollo/client";
 import { PRN, ServiceAbbreviation } from "@platecms/delta-plate-resource-notation";
-import { compact } from "lodash";
 import { defu } from "defu";
 
 const placeholderOrganizationPrn = new PRN(
@@ -63,7 +62,7 @@ function createApolloClient(
         fetchPolicy: "cache-and-network" as FetchPolicy,
       },
     },
-    link: from(compact([options?.errorLink, authLink.concat(httpLink)])),
+    link: from([options?.errorLink, authLink.concat(httpLink)].filter((value) => value !== undefined)),
   });
 }
 

package/src/schema/lib/schemas/array.ts

@@ -1,5 +1,5 @@
-import { compact, first } from "lodash";
 import { Schema, SchemaConfig } from ".";
+import { compact, first } from "../utils";
 
 export class ArraySchema<T extends Schema | Schema[]>
   implements

package/src/schema/lib/schemas/baseSchema.ts

@@ -1,5 +1,5 @@
-import { isArray } from "lodash";
 import { ResultType, Schema, SchemaConfig } from ".";
+import { isArray } from "../utils";
 
 export abstract class BaseSchema<TResult extends ResultType, TData> implements Schema<TResult, TData> {
   protected _isNullable = true;

package/src/schema/lib/schemas/contentItem.ts

@@ -1,7 +1,6 @@
 import { ObjectSchema, Schema, SchemaConfig } from ".";
-import { isArray } from "lodash";
 import { isContentValue } from "../utils/isContentValue";
-
+import { isArray } from "../utils";
 export class ContentItemSchema<T extends Record<string, Schema | Schema[]>>
   implements Schema<ObjectSchema<T>, unknown>
 {

package/src/schema/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/schema/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);
+}