strapi-cms-audit-log 1.1.0

package/dist/admin/src/utils/format.d.ts

@@ -0,0 +1,41 @@
+import { AuditAction } from '../types';
+/** Badge colours per action, using design-system palette tokens. */
+export declare const ACTION_COLORS: Record<string, {
+    background: string;
+    text: string;
+}>;
+export declare const actionColor: (action: string) => {
+    background: string;
+    text: string;
+};
+/** `api::page.page` -> `page`. Falls back to the raw uid for anything unexpected. */
+export declare const shortContentTypeName: (uid: string) => string;
+/**
+ * A short, unambiguous rendering of a value inside a diff cell.
+ *
+ * Long strings and structured values are truncated: the cell is a summary, and
+ * the full value is one click away in the JSON viewer. `null` and `undefined`
+ * are rendered as words rather than as an empty cell, because "this field was
+ * cleared" and "this field was not part of the change" look identical otherwise.
+ */
+export declare const formatValue: (value: unknown, maxLength?: number) => string;
+/** True when a value is worth offering the collapsible JSON viewer for. */
+export declare const isStructured: (value: unknown) => boolean;
+/** `2026-09-02T13:10:00.000Z` -> `02 Sep 2026, 13:10`, in the viewer's locale. */
+export declare const formatDate: (value: string | null | undefined, locale?: string) => string;
+/** Best label for the actor behind a record. */
+export declare const formatUser: (log: {
+    userName: string | null;
+    userEmail: string | null;
+    userId: string | null;
+    source: string;
+}) => string;
+export declare const isAuditAction: (value: string) => value is AuditAction;
+/**
+ * True for a record that is about security rather than content.
+ *
+ * Derived from the action name rather than from a list, so an action added on
+ * the server needs no matching edit here. Every content action is a bare verb;
+ * every security action is either namespaced with a dot or is `logout`.
+ */
+export declare const isSecurityAction: (value: string) => boolean;

package/dist/admin/src/utils/getTranslation.d.ts

@@ -0,0 +1,2 @@
+/** Namespaces a translation key, so plugin keys cannot collide with the admin's. */
+export declare const getTranslation: (id: string) => string;

package/dist/admin/src/utils/widgets.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Turns a pair of raw snapshots into a per-widget before/after view.
+ *
+ * ## The problem this solves
+ *
+ * The server's diff engine flattens everything into dotted paths, so editing one
+ * widget on a page produces entries like `widgets[3].heading` and
+ * `widgets[3].cta.label`. That is exactly right for a field-level question
+ * ("what text changed?") and exactly wrong for the question editors actually
+ * ask, which is "what did that widget look like before, and what does it look
+ * like now?". Answering it from a flat path list means reading an index out of a
+ * string and mentally reassembling a component.
+ *
+ * So the widgets are reassembled here instead: each changed slot yields the
+ * whole component as it was and the whole component as it now is, and the detail
+ * page renders the widget twice, once per side.
+ *
+ * ## Why this runs in the browser
+ *
+ * Everything it needs is already on the record — `before` and `after` are
+ * returned in full by `GET /audit-log/logs/:id`. Computing it server-side would
+ * mean either a new stored column (wrong for existing rows, which would show
+ * nothing) or a per-request pass over two JSON blobs to produce something only
+ * the detail page reads. Doing it here also means the feature works
+ * retroactively, on every record already in the table.
+ *
+ * ## Why it is not schema-aware
+ *
+ * Nothing here knows what a "widget" is in any particular project. A dynamic
+ * zone is recognised structurally — an array whose members are objects carrying
+ * `__component` — which is how Strapi itself marks them in a populated result.
+ * That covers `widgets` on a page, `blocks` on an article and any zone added
+ * later, on any content type, with no list to maintain.
+ */
+/** One component instance inside a dynamic zone, as it appears in a snapshot. */
+export interface WidgetInstance {
+    __component: string;
+    [field: string]: unknown;
+}
+export type WidgetStatus = 'changed' | 'added' | 'removed' | 'unchanged';
+/** One slot of a dynamic zone, paired across the operation. */
+export interface WidgetSlot {
+    /** Position in the zone. The slot is the unit of comparison — see {@link pairSlots}. */
+    index: number;
+    status: WidgetStatus;
+    /** Component uid, from whichever side exists. */
+    component: string;
+    /** The component uid on the other side, when the slot was replaced with a different widget. */
+    replacedComponent: string | null;
+    before: WidgetInstance | null;
+    after: WidgetInstance | null;
+    /** Dotted field paths that differ, relative to the widget — `heading`, `cta.label`. */
+    changedFields: string[];
+}
+/** A dynamic zone attribute, with its slots paired. */
+export interface WidgetZone {
+    /** Attribute name on the content type — `widgets`, `blocks`. */
+    name: string;
+    slots: WidgetSlot[];
+    changedCount: number;
+}
+/**
+ * Every dynamic zone touched by an operation, with its slots paired.
+ *
+ * Returns an empty array when neither snapshot contains a zone, which is the
+ * signal for the detail page to omit the section entirely rather than render an
+ * empty heading. A zone identical on both sides is still returned — its slots
+ * are all `unchanged`, and the page shows them collapsed as context.
+ */
+export declare const extractWidgetZones: (before: Record<string, unknown> | null | undefined, after: Record<string, unknown> | null | undefined) => WidgetZone[];
+/** `home.hero` -> `Hero`. Falls back to the raw uid for anything unexpected. */
+export declare const widgetLabel: (component: string) => string;
+/**
+ * A widget flattened to the rows the card renders.
+ *
+ * Nested components are flattened into dotted paths so a card is a flat list of
+ * label/value pairs — the same shape whatever depth the field lives at, and the
+ * same shape the `changedFields` highlight is keyed by. Arrays and media objects
+ * stop the descent: below that point a card is the wrong tool and the raw JSON
+ * viewer is the right one.
+ */
+export declare const widgetRows: (widget: WidgetInstance | null, prefix?: string) => Array<{
+    path: string;
+    value: unknown;
+}>;