@byline/admin 5.1.4 → 5.2.0

package/dist/forms/form-status-display.jsx

@@ -1,69 +0,0 @@
-'use client';
-import { useTranslation } from '@byline/i18n/react';
-import cx from 'clsx';
-import { LocalDateTime } from '../fields/local-date-time';
-import styles from './form-renderer.module.css';
-/**
- * The status / metadata strip at the top of a document form — current
- * workflow status (suppressed for single-status workflows), last-modified and
- * created timestamps, and a "published live" indicator with an inline
- * Unpublish action when a previously-published version is still live.
- */
-export const FormStatusDisplay = ({ disabled = false, initialData, workflowStatuses, publishedVersion, onUnpublish, afterStatusCells, }) => {
-    const { t } = useTranslation('byline-admin');
-    const statusCode = initialData?.status;
-    const statusLabel = workflowStatuses?.find((s) => s.name === statusCode)?.label ?? statusCode;
-    // Single-status workflows (e.g. lookups) have no editorial lifecycle —
-    // suppress the "Status: …" cell since there is nothing meaningful to convey.
-    const showStatusCell = (workflowStatuses?.length ?? 0) > 1;
-    return (<div className={cx('byline-form-status', styles.status)}>
-      <div className={cx('byline-form-status-meta', styles['status-meta'])}>
-        {showStatusCell && (<div className={cx('byline-form-status-cell', styles['status-cell'])}>
-            <span className={cx('byline-form-status-muted', styles['status-muted'])}>
-              {t('forms.status.label')}
-            </span>
-            <span className={cx('byline-form-status-trunc', styles['status-trunc'])}>
-              {statusLabel}
-            </span>
-            {afterStatusCells}
-          </div>)}
-        {!showStatusCell && afterStatusCells}
-
-        {initialData?.updatedAt != null && (<div className={cx('byline-form-status-cell', styles['status-cell'])}>
-            <span className={cx('byline-form-status-muted', styles['status-muted'])}>
-              {t('forms.status.lastModified')}
-            </span>
-            <span className={cx('byline-form-status-trunc', styles['status-trunc'])}>
-              <LocalDateTime value={initialData.updatedAt}/>
-            </span>
-          </div>)}
-
-        {initialData?.createdAt != null && (<div className={cx('byline-form-status-cell', styles['status-cell'])}>
-            <span className={cx('byline-form-status-muted', styles['status-muted'])}>
-              {t('forms.status.created')}
-            </span>
-            <span className={cx('byline-form-status-trunc', styles['status-trunc'])}>
-              <LocalDateTime value={initialData.createdAt}/>
-            </span>
-          </div>)}
-      </div>
-
-      {publishedVersion != null && (<div className={cx('byline-form-status-published', styles['status-published'])}>
-          <span className={cx('byline-form-status-muted', styles['status-muted'])}>
-            {t('forms.status.publishedLive')}{' '}
-            {publishedVersion.updatedAt ? (<span>
-                {t('forms.status.publishedOn', { date: new Date(publishedVersion.updatedAt) })}
-              </span>) : ('')}
-          </span>
-          {onUnpublish && (<>
-              {' '}
-              <button type="button" disabled={disabled} onClick={() => {
-                    if (!disabled)
-                        void onUnpublish().catch(() => { });
-                }} className={cx('byline-form-status-unpublish', styles['status-unpublish'])}>
-                {t('common.actions.unpublish')}
-              </button>
-            </>)}
-        </div>)}
-    </div>);
-};

package/dist/forms/navigation-guard.jsx

@@ -1,68 +0,0 @@
-/**
- * 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
- */
-/**
- * Framework-agnostic navigation guard adapter.
- *
- * Different router frameworks (TanStack Router, Next.js, React Router, etc.)
- * each have their own mechanism for blocking navigation when a form has unsaved
- * changes.  This module defines a common interface so that `FormRenderer` can
- * remain framework-independent — the consuming application injects the
- * appropriate adapter via a prop or React context.
- */
-import { createContext, useContext, useEffect } from 'react';
-// ---------------------------------------------------------------------------
-// Default (no-op) implementation  — browser `beforeunload` only
-// ---------------------------------------------------------------------------
-/**
- * Fallback navigation guard that only handles the browser's native
- * `beforeunload` event.  In-app (client-side) route changes are **not**
- * intercepted — `isBlocked` will never become `true`.
- *
- * This is used when no framework-specific adapter has been provided.
- */
-export const useBeforeUnloadGuard = (shouldBlock) => {
-    useEffect(() => {
-        if (!shouldBlock)
-            return;
-        const handler = (e) => {
-            e.preventDefault();
-        };
-        window.addEventListener('beforeunload', handler);
-        return () => window.removeEventListener('beforeunload', handler);
-    }, [shouldBlock]);
-    return { isBlocked: false, stay: () => { }, proceed: () => { } };
-};
-// ---------------------------------------------------------------------------
-// React context — allows setting the adapter once at the app shell level
-// ---------------------------------------------------------------------------
-const NavigationGuardContext = createContext(useBeforeUnloadGuard);
-/**
- * Provide a framework-specific `UseNavigationGuard` hook to all descendant
- * `FormRenderer` instances.
- *
- * ```tsx
- * import { NavigationGuardProvider } from './navigation-guard'
- * import { useTanStackNavigationGuard } from './tanstack-navigation-guard'
- *
- * function App() {
- *   return (
- *     <NavigationGuardProvider value={useTanStackNavigationGuard}>
- *       <Outlet />
- *     </NavigationGuardProvider>
- *   )
- * }
- * ```
- */
-export const NavigationGuardProvider = NavigationGuardContext.Provider;
-/**
- * Consume the current `UseNavigationGuard` hook from context.
- * Falls back to `useBeforeUnloadGuard` when no provider is present.
- */
-export const useNavigationGuardAdapter = () => {
-    return useContext(NavigationGuardContext);
-};

package/dist/forms/nested-path.test.node.js

@@ -1,115 +0,0 @@
-/**
- * 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, hasExistingIdTargets, set, setWithResult, 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('selects nested repeating items by stable id', () => {
-        const value = {
-            content: [
-                {
-                    _id: 'block-b',
-                    gallery: [
-                        { _id: 'image-1', alt: 'one' },
-                        { _id: 'image-2', alt: 'two' },
-                    ],
-                },
-            ],
-        };
-        expect(get(value, 'content[id=block-b].gallery[id=image-2].alt')).toBe('two');
-        expect(get(value, 'content[id=missing].gallery[id=image-2].alt')).toBeUndefined();
-    });
-    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 = {};
-        set(o, 'a.b.c', 1);
-        expect(o).toEqual({ a: { b: { c: 1 } } });
-    });
-    it('creates arrays for numeric index segments', () => {
-        const o = {};
-        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 = {};
-        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 = { 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 = { 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('writes through nested stable-id selectors without changing array order', () => {
-        const o = {
-            content: [
-                { _id: 'a', gallery: [{ _id: 'x', alt: 'keep' }] },
-                { _id: 'b', gallery: [{ _id: 'y', alt: 'old' }] },
-            ],
-        };
-        set(o, 'content[id=b].gallery[id=y].alt', 'new');
-        expect(o.content.map((item) => item._id)).toEqual(['a', 'b']);
-        expect(o.content[0]?.gallery[0]?.alt).toBe('keep');
-        expect(o.content[1]?.gallery[0]?.alt).toBe('new');
-    });
-    it('does not create a ghost item for an unknown stable id', () => {
-        const o = { items: [{ _id: 'a', title: 'keep' }] };
-        expect(setWithResult(o, 'items[id=gone].title', 'new')).toBe(false);
-        expect(o).toEqual({ items: [{ _id: 'a', title: 'keep' }] });
-        const missingContainer = { group: {} };
-        expect(setWithResult(missingContainer, 'group.items[id=gone].title', 'new')).toBe(false);
-        expect(missingContainer).toEqual({ group: {} });
-    });
-    it('returns the mutated root', () => {
-        const o = {};
-        expect(set(o, 'x', 1)).toBe(o);
-    });
-});
-describe('hasExistingIdTargets', () => {
-    const value = { items: [{ _id: 'a', nested: [{ _id: 'b' }] }] };
-    it('accepts live nested identities and rejects removed ones', () => {
-        expect(hasExistingIdTargets(value, 'items[id=a].nested[id=b].title')).toBe(true);
-        expect(hasExistingIdTargets(value, 'items[id=a].nested[id=gone].title')).toBe(false);
-        expect(hasExistingIdTargets(value, 'title')).toBe(true);
-    });
-});

package/dist/forms/path-widget.jsx

@@ -1,125 +0,0 @@
-'use client';
-/**
- * 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 { useCallback, useMemo } from 'react';
-import { slugify } from '@byline/core';
-import { useTranslation } from '@byline/i18n/react';
-import { Input, Label } from '@byline/ui/react';
-import cx from 'clsx';
-import { useFieldValue, useFormContext, useSystemPath } from './form-context';
-import styles from './path-widget.module.css';
-/**
- * Coerce an arbitrary source-field value (string, Date, or other) into
- * a string suitable for slugification. Mirrors the lifecycle's coercion
- * so the live preview matches what the server will store.
- */
-function coerceToString(value) {
-    if (value == null)
-        return '';
-    if (value instanceof Date)
-        return value.toISOString();
-    return String(value);
-}
-/**
- * System-managed `path` widget.
- *
- * Edits the path stored in `byline_document_paths` for the current
- * (document, locale) row. Displays the current persisted/overridden
- * value as an editable input.
- * In create mode, when the user hasn't supplied an override, the input
- * shows the live-derived preview (slugified `useAsPath` source field) as
- * a placeholder so the user sees what will be saved. The "Regenerate"
- * action explicitly writes the current live preview into the override
- * slot so the user can re-anchor a path against the source field after
- * editing the title.
- *
- * Stable override handles: `.byline-form-path`, `.byline-form-path-header`,
- * `.byline-form-path-regenerate`.
- */
-export const PathWidget = ({ useAsPath, collectionPath, defaultLocale, activeLocale, mode, slugifier, sourceLocked = false, disabled = false, }) => {
-    const { setSystemPath } = useFormContext();
-    const { t } = useTranslation('byline-admin');
-    const systemPath = useSystemPath();
-    const sourceValue = useFieldValue(useAsPath ?? '');
-    // The installation slugifier, or the built-in default. Server-side path
-    // derivation uses `ServerConfig.slugifier`; this must be the same function
-    // (registered via `AdminConfig.slugifier`) or the preview will disagree
-    // with what the server persists.
-    const runSlugify = slugifier ?? slugify;
-    // Phase 1: paths are written/edited only under the default content
-    // locale. When editing a translation, the widget locks down — the
-    // input is read-only, the Regenerate action is suppressed, and a
-    // helpText line explains why.
-    const isReadOnly = activeLocale !== defaultLocale;
-    // Live preview — what the server would derive from the current source
-    // field value if no override were set. Used as placeholder in create
-    // mode and as the target of the "Regenerate" action.
-    const livePreview = useMemo(() => {
-        // A locked source (server-assigned counter / read-only field) can't be
-        // previewed or regenerated from the form — suppress the derivation.
-        if (!useAsPath || sourceLocked)
-            return '';
-        const asString = coerceToString(sourceValue);
-        if (asString.length === 0)
-            return '';
-        return runSlugify(asString, { locale: defaultLocale, collectionPath });
-    }, [useAsPath, sourceLocked, sourceValue, defaultLocale, collectionPath, runSlugify]);
-    const inputValue = systemPath ?? '';
-    const handleChange = useCallback((next) => {
-        if (disabled)
-            return;
-        // Empty string clears the override — server falls back to derive
-        // (create) or sticky (update).
-        setSystemPath(next.length === 0 ? null : next);
-    }, [disabled, setSystemPath]);
-    const handleRegenerate = useCallback(() => {
-        if (!disabled && livePreview.length > 0) {
-            setSystemPath(livePreview);
-        }
-    }, [disabled, livePreview, setSystemPath]);
-    // Validate live: if the typed value differs from its slugified form,
-    // surface an inline hint without blocking input (mirrors the previous
-    // field-hook advisory behaviour).
-    const formatted = useMemo(() => {
-        if (inputValue.length === 0)
-            return '';
-        return runSlugify(inputValue, { locale: defaultLocale, collectionPath });
-    }, [inputValue, defaultLocale, collectionPath, runSlugify]);
-    const validationHint = inputValue.length > 0 && formatted !== inputValue
-        ? t('pathWidget.suggestedHint', { formatted })
-        : undefined;
-    // When read-only, replace the live validation hint with a fixed
-    // explanatory line so editors understand why the field is locked.
-    const readOnlyHint = isReadOnly
-        ? t('pathWidget.readOnlyHint', { locale: defaultLocale })
-        : undefined;
-    const hint = readOnlyHint ?? validationHint;
-    const placeholder = !isReadOnly && mode === 'create' && livePreview.length > 0
-        ? t('pathWidget.willBeSavedAs', { preview: livePreview })
-        : undefined;
-    // Screen-reader description. The input's base purpose ("System-managed
-    // URL path") plus whichever of the visible hints (placeholder preview
-    // in create mode, "Suggested" validation hint, or read-only explainer)
-    // currently applies. The visible helpText/placeholder cover sighted
-    // users; this element makes the same information addressable via
-    // aria-describedby for AT.
-    const srDescription = [t('pathWidget.srDescription'), placeholder, hint].filter(Boolean).join(' ');
-    const showRegenerate = !isReadOnly && useAsPath && livePreview.length > 0 && livePreview !== systemPath;
-    return (<div className="byline-form-path">
-      <div className={cx('byline-form-path-header', styles.header)}>
-        <Label id="system-path-label" htmlFor="system-path" label={t('pathWidget.label')}/>
-        {showRegenerate && (<button type="button" onClick={handleRegenerate} className={cx('byline-form-path-regenerate', styles.regenerate)} disabled={disabled} aria-label={t('pathWidget.regenerateAriaLabel', { field: useAsPath })}>
-            {t('pathWidget.regenerateButton', { field: useAsPath })}
-          </button>)}
-      </div>
-      <Input disabled={disabled} id="system-path" name="__systemPath__" value={inputValue} placeholder={placeholder} onChange={(e) => handleChange(e.target.value)} helpText={hint} readOnly={isReadOnly} aria-describedby="system-path-description"/>
-      <span id="system-path-description" className={cx('byline-form-path-sr-only', styles['sr-only'])}>
-        {srDescription}
-      </span>
-    </div>);
-};

package/dist/forms/pending-uploads.test.node.js

@@ -1,19 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { deletePendingUploadsUnderPath } from './pending-uploads';
-describe('deletePendingUploadsUnderPath', () => {
-    it('removes and revokes only uploads beneath the removed item', () => {
-        const uploads = new Map([
-            ['content[id=a].image', { previewUrl: 'blob:a' }],
-            ['content[id=b].image', { previewUrl: 'blob:b' }],
-            ['content[id=b].gallery[id=x].image', { previewUrl: 'blob:nested' }],
-        ]);
-        const revoke = vi.fn();
-        expect(deletePendingUploadsUnderPath(uploads, 'content[id=b]', revoke)).toBe(true);
-        expect([...uploads.keys()]).toEqual(['content[id=a].image']);
-        expect(revoke.mock.calls).toEqual([['blob:b'], ['blob:nested']]);
-    });
-    it('reports when no pending upload matched', () => {
-        const uploads = new Map([['content[id=a].image', { previewUrl: 'blob:a' }]]);
-        expect(deletePendingUploadsUnderPath(uploads, 'content[id=b]', vi.fn())).toBe(false);
-    });
-});

package/dist/forms/repeating-items.test.node.js

@@ -1,29 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { moveRepeatingItems, repeatingItemId, repeatingItemPath } from './repeating-items';
-describe('repeatingItemPath', () => {
-    it('uses stable storage identity when available', () => {
-        expect(repeatingItemPath('content', { _id: 'block-b' }, 1)).toBe('content[id=block-b]');
-    });
-    it('falls back to position for id-less or path-unsafe identities', () => {
-        expect(repeatingItemPath('content', {}, 1)).toBe('content[1]');
-        expect(repeatingItemPath('content', { _id: 'unsafe.id' }, 1)).toBe('content[1]');
-        expect(repeatingItemPath('content', { _id: null }, 1)).toBe('content[1]');
-        expect(repeatingItemId({ _id: 42 })).toBeUndefined();
-    });
-});
-describe('moveRepeatingItems', () => {
-    const ids = (items) => items.map((item) => item._id);
-    it('keeps consecutive moves aligned with the current form-store order', () => {
-        const first = moveRepeatingItems([{ _id: 'a' }, { _id: 'b' }, { _id: 'c' }], 2, 0);
-        expect(first?.itemId).toBe('c');
-        expect(ids(first?.items ?? [])).toEqual(['c', 'a', 'b']);
-        const second = moveRepeatingItems(first?.items ?? [], 2, 1);
-        expect(second?.itemId).toBe('b');
-        expect(ids(second?.items ?? [])).toEqual(['c', 'b', 'a']);
-    });
-    it('retains the positional patch fallback for id-less items', () => {
-        const moved = moveRepeatingItems([{ value: 'a' }, { value: 'b' }], 1, 0);
-        expect(moved?.itemId).toBe('1');
-        expect(moved?.items.map((item) => item.value)).toEqual(['b', 'a']);
-    });
-});