@byline/admin 2.5.2 → 2.6.0

package/dist/fields/text-area/text-area-field.js

@@ -0,0 +1,105 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useCallback } from "react";
+import { Label, TextArea } from "@byline/ui/react";
+import classnames from "classnames";
+import { useFieldError, useFieldValue } from "../../forms/form-context.js";
+import { LocaleBadge } from "../locale-badge.js";
+import text_area_field_module from "./text-area-field.module.js";
+const TextAreaField = ({ field, value, defaultValue, onChange, id, path, locale, components })=>{
+    const fieldPath = path ?? field.name;
+    const fieldError = useFieldError(fieldPath);
+    const fieldValue = useFieldValue(fieldPath);
+    const incomingValue = value ?? fieldValue ?? defaultValue ?? '';
+    const htmlId = id ?? fieldPath;
+    const handleChange = useCallback((value)=>{
+        if (onChange) onChange(value);
+    }, [
+        onChange
+    ]);
+    const slots = components;
+    const CustomLabel = slots?.Label;
+    const CustomHelpText = slots?.HelpText;
+    const CustomField = slots?.Field;
+    const BeforeField = slots?.beforeField;
+    const AfterField = slots?.afterField;
+    const slotBaseProps = {
+        field: field,
+        path: fieldPath,
+        value: incomingValue,
+        error: fieldError,
+        id: htmlId
+    };
+    const showBadge = !!locale && !!field.label;
+    const hasCustomLabel = !!CustomLabel;
+    const suppressInputLabel = showBadge || hasCustomLabel;
+    const suppressInputHelpText = !!CustomHelpText;
+    const labelRowClass = classnames('byline-field-text-area-label-row', text_area_field_module["label-row"]);
+    const renderLabel = ()=>{
+        if (hasCustomLabel) return /*#__PURE__*/ jsxs("div", {
+            className: labelRowClass,
+            children: [
+                /*#__PURE__*/ jsx(CustomLabel, {
+                    ...slotBaseProps,
+                    label: field.label,
+                    required: !field.optional
+                }),
+                showBadge && /*#__PURE__*/ jsx(LocaleBadge, {
+                    locale: locale
+                })
+            ]
+        });
+        if (showBadge) return /*#__PURE__*/ jsxs("div", {
+            className: labelRowClass,
+            children: [
+                /*#__PURE__*/ jsx(Label, {
+                    id: `${htmlId}-label`,
+                    htmlFor: htmlId,
+                    label: field.label,
+                    required: !field.optional
+                }),
+                /*#__PURE__*/ jsx(LocaleBadge, {
+                    locale: locale
+                })
+            ]
+        });
+        return null;
+    };
+    const renderInput = ()=>{
+        if (CustomField) return /*#__PURE__*/ jsx(CustomField, {
+            ...slotBaseProps,
+            onChange: handleChange,
+            defaultValue: defaultValue,
+            placeholder: field.placeholder
+        });
+        return /*#__PURE__*/ jsx(TextArea, {
+            id: htmlId,
+            name: field.name,
+            label: suppressInputLabel ? void 0 : field.label,
+            required: !field.optional,
+            helpText: suppressInputHelpText ? void 0 : field.helpText,
+            value: incomingValue,
+            onChange: (e)=>handleChange(e.target.value),
+            error: null != fieldError,
+            errorText: fieldError,
+            rows: 4
+        });
+    };
+    return /*#__PURE__*/ jsxs("div", {
+        className: `byline-field-text-area ${field.name}`,
+        children: [
+            renderLabel(),
+            BeforeField && /*#__PURE__*/ jsx(BeforeField, {
+                ...slotBaseProps
+            }),
+            renderInput(),
+            AfterField && /*#__PURE__*/ jsx(AfterField, {
+                ...slotBaseProps
+            }),
+            CustomHelpText && /*#__PURE__*/ jsx(CustomHelpText, {
+                ...slotBaseProps,
+                helpText: field.helpText
+            })
+        ]
+    });
+};
+export { TextAreaField };

package/dist/fields/text-area/text-area-field.module.js

@@ -0,0 +1,6 @@
+import "./text-area-field_module.css";
+const text_area_field_module = {
+    "label-row": "label-row-HwX7C9",
+    labelRow: "label-row-HwX7C9"
+};
+export default text_area_field_module;

package/dist/fields/text-area/text-area-field_module.css

@@ -0,0 +1,5 @@
+:is(.label-row-HwX7C9, .byline-field-text-area-label-row) {
+  align-items: center;
+  display: flex;
+}
+

package/dist/fields/use-field-change-handler.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 type { Field } from '@byline/core';
+/**
+ * Returns a change handler for the given field that runs through the
+ * field-hook pipeline before committing the value:
+ *
+ *   1. `clearFieldError(path)`
+ *   2. `field.hooks.beforeValidate(ctx)` — advisory: may set an error on
+ *      the field but the value is **always** committed (user can keep typing)
+ *   3. `field.hooks.beforeChange(ctx)` — may return `{ value }` to replace
+ *      or `{ error }` to block the change entirely
+ *   4. `setFieldValue(path, finalValue)`
+ *
+ * When the field has no hooks the function is a zero-overhead pass-through
+ * to `setFieldValue` (no promises, no extra allocations).
+ */
+export declare function useFieldChangeHandler(field: Field, path: string): (value: any) => void;

package/dist/fields/use-field-change-handler.js

@@ -0,0 +1,52 @@
+import { useCallback } from "react";
+import { normalizeHooks } from "@byline/core";
+import { useFormContext } from "../forms/form-context.js";
+function useFieldChangeHandler(field, path) {
+    const { setFieldValue, getFieldValue, getFieldValues, setFieldError, clearFieldError } = useFormContext();
+    return useCallback((value)=>{
+        const hooks = field.hooks;
+        const validateFns = normalizeHooks(hooks?.beforeValidate);
+        const changeFns = normalizeHooks(hooks?.beforeChange);
+        if (0 === validateFns.length && 0 === changeFns.length) return void setFieldValue(path, value);
+        const previousValue = getFieldValue(path);
+        const ctx = {
+            value,
+            previousValue,
+            data: getFieldValues(),
+            path,
+            field,
+            operation: 'change'
+        };
+        clearFieldError(path);
+        if (0 === changeFns.length) setFieldValue(path, value);
+        (async ()=>{
+            try {
+                let advisoryError;
+                for (const fn of validateFns){
+                    const result = await fn(ctx);
+                    if (result?.error) advisoryError = result.error;
+                    if (result?.value !== void 0) ctx.value = result.value;
+                }
+                for (const fn of changeFns){
+                    const result = await fn(ctx);
+                    if (result?.error) return void setFieldError(path, result.error);
+                    if (result?.value !== void 0) ctx.value = result.value;
+                }
+                setFieldValue(path, ctx.value);
+                if (advisoryError) setFieldError(path, advisoryError);
+            } catch (err) {
+                const message = err instanceof Error ? err.message : 'Unexpected hook error';
+                setFieldError(path, message);
+            }
+        })();
+    }, [
+        field,
+        path,
+        setFieldValue,
+        getFieldValue,
+        getFieldValues,
+        setFieldError,
+        clearFieldError
+    ]);
+}
+export { useFieldChangeHandler };

package/dist/forms/document-actions.d.ts

@@ -0,0 +1,48 @@
+import type { PublishedVersionInfo } from './form-renderer';
+/**
+ * Shape of a content-locale option as consumed by the Copy-to-Locale
+ * modal. Matches the host adapter's `ContentLocaleOption`; declared
+ * locally so this package does not take a dependency on host code.
+ */
+export interface DocumentActionsLocaleOption {
+    code: string;
+    label: string;
+}
+export declare function DocumentActions({ publishedVersion, onUnpublish, onDelete, onDuplicate, sourceTitle, onCopyToLocale, sourceLocale, contentLocales, }: {
+    publishedVersion?: PublishedVersionInfo | null;
+    onUnpublish?: () => Promise<void>;
+    onDelete?: () => Promise<void>;
+    /**
+     * Called when the editor confirms the duplicate modal. The parent runs
+     * the server fn, surfaces a toast, and navigates to the new document.
+     */
+    onDuplicate?: () => Promise<void>;
+    /**
+     * The current (saved) value of the source document's `useAsTitle`
+     * field, used to render the suffix preview inside the duplicate modal.
+     * Sourced from the form's `initialData`, not live form state, so the
+     * preview reflects what will actually be duplicated.
+     */
+    sourceTitle?: string | null;
+    /**
+     * Called when the editor confirms the Copy-to-Locale modal. The
+     * parent runs the server fn, surfaces a toast, and navigates to the
+     * target locale view. Menu item is hidden when omitted, or when fewer
+     * than two content locales are configured.
+     */
+    onCopyToLocale?: (args: {
+        targetLocale: string;
+        overwrite: boolean;
+    }) => Promise<void>;
+    /**
+     * The locale the form is currently displaying. Used as the read-only
+     * "From" label in the Copy-to-Locale modal and excluded from the
+     * target Select.
+     */
+    sourceLocale?: string;
+    /**
+     * All configured content locales (code + display label). The
+     * Copy-to-Locale Select lists every locale except `sourceLocale`.
+     */
+    contentLocales?: ReadonlyArray<DocumentActionsLocaleOption>;
+}): import("react").JSX.Element;