Remove vendored compiler lodash dependency

Author: RhysSullivan

bun.lock

@@ -71,7 +71,6 @@
     "fractional-indexing": "^3.2.0",
     "fumadb": "workspace:*",
     "js-yaml": "^4.1.1",
-    "lodash": "^4.18.1",
     "oauth4webapi": "^3.8.5"
   },
   "devDependencies": {
@@ -80,8 +79,6 @@
     "@effect/vitest": "catalog:",
     "@types/better-sqlite3": "^7.6.13",
     "@types/js-yaml": "^4.0.9",
-    "@types/json-schema": "^7.0.15",
-    "@types/lodash": "^4.17.24",
     "@types/node": "catalog:",
     "@types/react": "catalog:",
     "better-sqlite3": "^12.9.0",

packages/core/sdk/package.json

@@ -1,4 +1,4 @@
-import { memoize, omit } from "lodash";
+import { memoize, omit } from "./lodash";
 import { DEFAULT_OPTIONS, type Options } from "./index";
 import { hasComment, hasStandaloneName, T_ANY, T_UNKNOWN } from "./types/AST";
 import type {

packages/core/sdk/src/vendor/json-schema-to-typescript/generator.ts

@@ -1,9 +1,9 @@
 /// <reference types="node" />
 
 import { readFileSync } from "fs";
-import type { JSONSchema4 } from "json-schema";
+import type { JSONSchema4 } from "./types/json-schema";
 import type { ParserOptions as $RefOptions } from "@apidevtools/json-schema-ref-parser";
-import { cloneDeep, endsWith, merge } from "lodash";
+import { cloneDeep, endsWith, merge } from "./lodash";
 import { dirname } from "path";
 import { format } from "./formatter";
 import { generate } from "./generator";

packages/core/sdk/src/vendor/json-schema-to-typescript/index.ts

@@ -1,7 +1,7 @@
 import { Parent } from "./types/JSONSchema";
 import type { JSONSchema, LinkedJSONSchema } from "./types/JSONSchema";
-import { isPlainObject } from "lodash";
-import type { JSONSchema4Type } from "json-schema";
+import { isPlainObject } from "./lodash";
+import type { JSONSchema4Type } from "./types/json-schema";
 
 /**
  * Traverses over the schema, giving each node a reference to its

packages/core/sdk/src/vendor/json-schema-to-typescript/linker.ts

@@ -0,0 +1,81 @@
+export const isPlainObject = (value: unknown): value is Record<string, unknown> => {
+  if (value === null || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+
+export const cloneDeep = <T>(value: T): T => structuredClone(value);
+
+export const endsWith = (value: string, suffix: string): boolean => value.endsWith(suffix);
+
+export const merge = <T extends Record<string, unknown>>(
+  target: T,
+  ...sources: ReadonlyArray<Record<string, unknown> | undefined>
+): T => {
+  for (const source of sources) {
+    if (!source) continue;
+    for (const [key, value] of Object.entries(source)) {
+      const current = target[key];
+      target[key] =
+        isPlainObject(current) && isPlainObject(value)
+          ? merge({ ...current }, value)
+          : cloneDeep(value);
+    }
+  }
+  return target;
+};
+
+export const findKey = <T>(
+  object: Record<string, T> | undefined,
+  predicate: (value: T, key: string) => boolean,
+): string | undefined => {
+  if (!object) return undefined;
+  for (const [key, value] of Object.entries(object)) {
+    if (predicate(value, key)) return key;
+  }
+  return undefined;
+};
+
+export const includes = <T>(array: ReadonlyArray<T>, value: T): boolean => array.includes(value);
+
+export const map = <T, U>(
+  object: Record<string, T> | undefined,
+  iteratee: (value: T, key: string) => U,
+): U[] => (object ? Object.entries(object).map(([key, value]) => iteratee(value, key)) : []);
+
+export const memoize = <F extends (arg: any, ...rest: any[]) => any>(fn: F): F => {
+  const cache = new Map<Parameters<F>[0], ReturnType<F>>();
+  return ((arg: Parameters<F>[0], ...rest: unknown[]) => {
+    if (cache.has(arg)) return cache.get(arg);
+    const value = fn(arg, ...rest);
+    cache.set(arg, value);
+    return value;
+  }) as F;
+};
+
+export const omit = <T extends object, K extends keyof T>(object: T, ...keys: K[]): Omit<T, K> => {
+  const omitted = new Set<PropertyKey>(keys);
+  return Object.fromEntries(
+    Object.entries(object).filter(([key]) => !omitted.has(key)),
+  ) as Omit<T, K>;
+};
+
+export const uniqBy = <T>(items: ReadonlyArray<T>, iteratee: (value: T) => string): T[] => {
+  const seen = new Set<string>();
+  const result: T[] = [];
+  for (const item of items) {
+    const key = iteratee(item);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(item);
+  }
+  return result;
+};
+
+export const deburr = (value: string): string =>
+  value.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+
+export const trim = (value: string): string => value.trim();
+
+export const upperFirst = (value: string): string =>
+  value.length === 0 ? value : value[0]!.toUpperCase() + value.slice(1);

packages/core/sdk/src/vendor/json-schema-to-typescript/lodash.ts

@@ -1,4 +1,4 @@
-import { uniqBy } from "lodash";
+import { uniqBy } from "./lodash";
 import type { Options } from ".";
 import { generateType } from "./generator";
 import { T_ANY, T_UNKNOWN } from "./types/AST";

packages/core/sdk/src/vendor/json-schema-to-typescript/optimizer.ts

@@ -1,5 +1,5 @@
-import type { JSONSchema4Type, JSONSchema4TypeName } from "json-schema";
-import { findKey, includes, isPlainObject, map, memoize, omit } from "lodash";
+import type { JSONSchema4Type, JSONSchema4TypeName } from "./types/json-schema";
+import { findKey, includes, isPlainObject, map, memoize, omit } from "./lodash";
 import { format } from "util";
 import type { Options } from "./";
 import { applySchemaTyping } from "./applySchemaTyping";

packages/core/sdk/src/vendor/json-schema-to-typescript/parser.ts

@@ -1,4 +1,4 @@
-import type { JSONSchema4Type } from "json-schema";
+import type { JSONSchema4Type } from "./json-schema";
 
 export type AST_TYPE = AST["type"];
 

packages/core/sdk/src/vendor/json-schema-to-typescript/types/AST.ts

@@ -1,5 +1,5 @@
-import type { JSONSchema4, JSONSchema4Type, JSONSchema4TypeName } from "json-schema";
-import { isPlainObject, memoize } from "lodash";
+import type { JSONSchema4, JSONSchema4Type, JSONSchema4TypeName } from "./json-schema";
+import { isPlainObject, memoize } from "../lodash";
 
 export type SchemaType =
   | "ALL_OF"