@byline/admin 3.2.0 → 3.2.1

package/dist/forms/form-context.js

@@ -2,7 +2,7 @@
 import { jsx } from "react/jsx-runtime";
 import { createContext, useCallback, useContext, useEffect, useRef, useState } from "react";
 import { normalizeHooks } from "@byline/core";
-import { get, set as external_lodash_es_set } from "lodash-es";
+import { get, set as external_nested_path_js_set } from "./nested-path.js";
 const sameLocaleSet = (a, b)=>{
     if (a.length !== b.length) return false;
     const sa = [
@@ -84,7 +84,7 @@ const FormProvider = ({ children, initialData = {} })=>{
         const newFieldValues = {
             ...fieldValues.current
         };
-        external_lodash_es_set(newFieldValues, name, value);
+        external_nested_path_js_set(newFieldValues, name, value);
         fieldValues.current = newFieldValues;
         dirtyFields.current.add(name);
         notifyFieldListeners(name, value);

package/dist/forms/nested-path.d.ts

@@ -0,0 +1,24 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ *
+ * Minimal nested `get`/`set` over string field paths, replacing lodash-es
+ * (which pulled a large shared chunk onto unrelated bundles). Supports the
+ * dot + bracket notation produced by the form field-path builders, e.g.
+ * `title`, `a.b.c`, `items[0].title`, `blocks[2].nested[1].field`.
+ *
+ * `set` mirrors lodash semantics: it creates intermediate **arrays** when the
+ * next path segment is a numeric index and plain **objects** otherwise, and it
+ * mutates `object` in place (callers shallow-copy the root first, as before).
+ *
+ * Deliberately NOT a general lodash replacement — it does not handle quoted
+ * keys (`a["b.c"]`), negative indices, or array-path inputs, none of which the
+ * form paths ever produce. See nested-path.test.node.ts for the covered cases.
+ */
+/** Split a field path into segments: `items[0].title` -> ['items','0','title']. */
+export declare function toPath(path: string): string[];
+export declare function get<T = any>(object: unknown, path: string): T;
+export declare function set<T extends object>(object: T, path: string, value: unknown): T;

package/dist/forms/nested-path.js

@@ -0,0 +1,29 @@
+const isIndexKey = (key)=>/^(?:0|[1-9]\d*)$/.test(key);
+function toPath(path) {
+    return path.match(/[^.[\]]+/g) ?? [];
+}
+function get(object, path) {
+    if (null == object) return;
+    let current = object;
+    for (const key of toPath(path)){
+        if (null == current) return;
+        current = current[key];
+    }
+    return current;
+}
+function set(object, path, value) {
+    if (null == object) return object;
+    const keys = toPath(path);
+    if (0 === keys.length) return object;
+    let current = object;
+    for(let i = 0; i < keys.length - 1; i++){
+        const key = keys[i];
+        const nextKey = keys[i + 1];
+        const existing = current[key];
+        if (null == existing || 'object' != typeof existing) current[key] = isIndexKey(nextKey) ? [] : {};
+        current = current[key];
+    }
+    current[keys[keys.length - 1]] = value;
+    return object;
+}
+export { get, set, toPath };

package/dist/forms/nested-path.test.node.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export {};

package/package.json

@@ -2,7 +2,7 @@
   "name": "@byline/admin",
   "private": false,
   "license": "MPL-2.0",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -142,15 +142,14 @@
     "@tanstack/react-form-start": "^1.32.0",
     "classnames": "^2.5.1",
     "jose": "^6.2.3",
-    "lodash-es": "^4.18.1",
     "react-diff-viewer-continued": "^4.2.2",
     "uuid": "^14.0.0",
     "zod": "^4.4.3",
     "zod-form-data": "^3.0.1",
-    "@byline/auth": "3.2.0",
-    "@byline/core": "3.2.0",
-    "@byline/ui": "3.2.0",
-    "@byline/i18n": "3.2.0"
+    "@byline/core": "3.2.1",
+    "@byline/i18n": "3.2.1",
+    "@byline/ui": "3.2.1",
+    "@byline/auth": "3.2.1"
   },
   "peerDependencies": {
     "react": "^19.0.0",
@@ -160,7 +159,6 @@
     "@biomejs/biome": "2.4.15",
     "@rsbuild/plugin-react": "^2.0.0",
     "@rslib/core": "^0.21.5",
-    "@types/lodash-es": "^4.17.12",
     "@types/node": "^25.9.1",
     "@types/react": "19.2.15",
     "@types/react-dom": "19.2.3",

package/src/forms/form-context.tsx

@@ -14,7 +14,12 @@ import { createContext, useCallback, useContext, useEffect, useRef, useState } f
 import type { Field, FieldBeforeChangeResult, FieldHookContext } from '@byline/core'
 import { normalizeHooks } from '@byline/core'
 import type { DocumentPatch, FieldSetPatch } from '@byline/core/patches'
-import { get as getNestedValue, set as setNestedValue } from 'lodash-es'
+
+// Vendored nested get/set (see ./nested-path) — removes the lodash-es dep
+// outright. A bare `from 'lodash-es'` import otherwise pools into a single
+// ~85KB chunk that leaks onto the public frontend bundle (form-context is
+// reachable from the layout graph).
+import { get as getNestedValue, set as setNestedValue } from './nested-path'
 
 interface FormError {
   field: string

package/src/forms/nested-path.test.node.ts

@@ -0,0 +1,85 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+import { describe, expect, it } from 'vitest'
+
+import { get, set, toPath } from './nested-path'
+
+describe('toPath', () => {
+  it('parses dot and bracket notation', () => {
+    expect(toPath('title')).toEqual(['title'])
+    expect(toPath('a.b.c')).toEqual(['a', 'b', 'c'])
+    expect(toPath('items[0].title')).toEqual(['items', '0', 'title'])
+    expect(toPath('blocks[2].nested[1].field')).toEqual(['blocks', '2', 'nested', '1', 'field'])
+  })
+})
+
+describe('get', () => {
+  const obj = { a: { b: 1, zero: 0, empty: '' }, items: [{ title: 'x' }, { title: 'y' }] }
+
+  it('reads nested, array, and mixed paths', () => {
+    expect(get(obj, 'a.b')).toBe(1)
+    expect(get(obj, 'items[0].title')).toBe('x')
+    expect(get(obj, 'items[1].title')).toBe('y')
+  })
+
+  it('preserves falsy values (does not conflate with missing)', () => {
+    expect(get(obj, 'a.zero')).toBe(0)
+    expect(get(obj, 'a.empty')).toBe('')
+  })
+
+  it('returns undefined for missing paths or nullish roots', () => {
+    expect(get(obj, 'a.x')).toBeUndefined()
+    expect(get(obj, 'missing.deep.path')).toBeUndefined()
+    expect(get(obj, 'items[5].title')).toBeUndefined()
+    expect(get(null, 'a.b')).toBeUndefined()
+    expect(get(undefined, 'a.b')).toBeUndefined()
+  })
+})
+
+describe('set', () => {
+  it('sets simple and nested values, creating intermediate objects', () => {
+    const o: any = {}
+    set(o, 'a.b.c', 1)
+    expect(o).toEqual({ a: { b: { c: 1 } } })
+  })
+
+  it('creates arrays for numeric index segments', () => {
+    const o: any = {}
+    set(o, 'items[0].title', 'x')
+    expect(Array.isArray(o.items)).toBe(true)
+    expect(o.items[0]).toEqual({ title: 'x' })
+  })
+
+  it('handles deep, mixed array/object paths', () => {
+    const o: any = {}
+    set(o, 'blocks[1].nested[0].field', 42)
+    expect(Array.isArray(o.blocks)).toBe(true)
+    expect(Array.isArray(o.blocks[1].nested)).toBe(true)
+    expect(o.blocks[1].nested[0].field).toBe(42)
+  })
+
+  it('overwrites existing values and preserves siblings', () => {
+    const o: any = { a: { b: 1, keep: 2 } }
+    set(o, 'a.b', 9)
+    expect(o).toEqual({ a: { b: 9, keep: 2 } })
+  })
+
+  it('writes into a pre-existing array element without clobbering the array', () => {
+    const o: any = { items: [{ title: 'x' }, { title: 'y' }] }
+    set(o, 'items[1].title', 'z')
+    expect(o.items[1].title).toBe('z')
+    expect(o.items[0].title).toBe('x')
+    expect(Array.isArray(o.items)).toBe(true)
+  })
+
+  it('returns the mutated root', () => {
+    const o: any = {}
+    expect(set(o, 'x', 1)).toBe(o)
+  })
+})

package/src/forms/nested-path.ts

@@ -0,0 +1,60 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ *
+ * Minimal nested `get`/`set` over string field paths, replacing lodash-es
+ * (which pulled a large shared chunk onto unrelated bundles). Supports the
+ * dot + bracket notation produced by the form field-path builders, e.g.
+ * `title`, `a.b.c`, `items[0].title`, `blocks[2].nested[1].field`.
+ *
+ * `set` mirrors lodash semantics: it creates intermediate **arrays** when the
+ * next path segment is a numeric index and plain **objects** otherwise, and it
+ * mutates `object` in place (callers shallow-copy the root first, as before).
+ *
+ * Deliberately NOT a general lodash replacement — it does not handle quoted
+ * keys (`a["b.c"]`), negative indices, or array-path inputs, none of which the
+ * form paths ever produce. See nested-path.test.node.ts for the covered cases.
+ */
+
+const isIndexKey = (key: string): boolean => /^(?:0|[1-9]\d*)$/.test(key)
+
+/** Split a field path into segments: `items[0].title` -> ['items','0','title']. */
+export function toPath(path: string): string[] {
+  return path.match(/[^.[\]]+/g) ?? []
+}
+
+// Returns `any` (not `T | undefined`) to match lodash's loose `get` contract,
+// so existing call sites that treat the result as `any` keep type-checking.
+export function get<T = any>(object: unknown, path: string): T {
+  if (object == null) return undefined as T
+  let current: any = object
+  for (const key of toPath(path)) {
+    if (current == null) return undefined as T
+    current = current[key]
+  }
+  return current as T
+}
+
+export function set<T extends object>(object: T, path: string, value: unknown): T {
+  if (object == null) return object
+  const keys = toPath(path)
+  if (keys.length === 0) return object
+
+  let current: any = object
+  for (let i = 0; i < keys.length - 1; i++) {
+    // Bounded by the loop condition, so these indexed reads are always defined.
+    const key = keys[i] as string
+    const nextKey = keys[i + 1] as string
+    const existing = current[key]
+    if (existing == null || typeof existing !== 'object') {
+      // Create the container the next segment needs: array for an index, else object.
+      current[key] = isIndexKey(nextKey) ? [] : {}
+    }
+    current = current[key]
+  }
+  current[keys[keys.length - 1] as string] = value
+  return object
+}