@orangelogic/design-system 4.23.0 → 4.24.0

package/library/components/video.js

@@ -1,2 +1,2 @@
-import { n as e, t } from "../chunks/video.DhZIlWXu.js";
+import { n as e, t } from "../chunks/video.Ci7-upS9.js";
 export { t as VIDEO_BACKGROUND_SIZE_BY_OBJECT_FIT, e as default };

package/library/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orangelogic/design-system",
   "type": "module",
-  "version": "4.23.0",
+  "version": "4.24.0",
   "license": "UNLICENSED",
   "types": "library/types.d.ts",
   "scripts": {

package/library/packages/atoms/src/components/menu/menu.d.ts

@@ -49,6 +49,7 @@ export default class CxMenu extends CortexElement {
     runFirstUpdated(): void;
     private handleClick;
     private handleKeyDown;
+    private handleMouseDown;
     private handleSlotChange;
     /** Sets `tabindex="0"` on the selected item (`checked`/`active`), or the first item if none is selected. */
     private syncTabIndexToSelection;

package/library/packages/events/src/cx-capacity-week-bar.d.ts

@@ -4,7 +4,7 @@
  * presentational — it forwards pointer/keyboard intent to its container via
  * these events; all allocation math lives in the container.
  */
-/** Fired when a resizable band is pressed (drag-to-rebalance start). */
+/** Fired when a resizable band is pressed (drag-to-resize start). */
 export type CxCapacityWeekBarBandPointerDownEvent = CustomEvent<{
     /** Measured pixel width of the bar element at press time (drift-proof). */
     barWidth: number;
@@ -15,7 +15,7 @@ export type CxCapacityWeekBarBandPointerDownEvent = CustomEvent<{
 /** Fired when a band is stepped via the keyboard (Arrow / Page keys). */
 export type CxCapacityWeekBarBandStepEvent = CustomEvent<{
     categoryId: string;
-    /** Signed hours to apply to the grabbed band via the shared rebalance. */
+    /** Signed hours to apply to the stepped band only (the container clamps it). */
     deltaHours: number;
 }>;
 declare global {

package/library/packages/organisms/src/capacity-planner/capacity-core.d.ts

@@ -2,7 +2,7 @@ import { CapacityCategory } from '../../../types/src/capacity-planner';
 import { clamp, quantizeLargestRemainder } from '../../../utils/src/custom-element/math';
 import { isoWeekNumber } from '../../../utils/src/date';
 export { clamp, isoWeekNumber, quantizeLargestRemainder };
-/** Minimum hours a category bottoms out at when dragged down. */
+/** Minimum hours an active category bottoms out at when edited down. */
 export declare const FLOOR = 0.2;
 /**
  * Reserved id for the synthetic "Unavailable" pseudo-category. It is never
@@ -29,12 +29,6 @@ export interface CapacityConstraints {
     /** Optional per-category clamp (max hours a single REAL category may hold). */
     maxHourPerCell?: number;
 }
-/**
- * Adjust the largest non-pinned band so the total is exactly C, correcting any
- * accumulated float drift. `pinned` is the index that must not be touched
- * (the grabbed band on a drag); pass `-1` to allow correcting any band.
- */
-export declare function correctToCapacity(vals: number[], pinned: number, capacity: number): number[];
 /**
  * Per-band cap over the EFFECTIVE set (reals + Unavailable). The cap applies
  * to REAL categories only — the synthetic Unavailable band (always the LAST
@@ -48,9 +42,8 @@ export declare function effectiveCapFor(index: number, n: number, maxHourPerCell
  * across the bands at `indices`, proportional to `weightFor(j)`, writing the
  * result into `vals[j]`. Implemented as a capped water-fill: whenever a band
  * would exceed `capFor(j)`, it is pinned at its cap and its surplus spills onto
- * the still-uncapped bands. Each band gets at least `floorFor(j)`. This is the
- * ONE implementation shared by `rebalance` and the copy/fill/paste normalize so
- * the cap behaviour cannot diverge between drag and copy.
+ * the still-uncapped bands. Each band gets at least `floorFor(j)`. Used by the
+ * copy/fill/paste normalize (`normalizeWeekToCapacity`) to enforce the cap.
  */
 export declare function cappedWaterFill(vals: number[], indices: number[], pool: number, capFor: (index: number) => number, floorFor: (index: number) => number, weightFor: (index: number) => number): void;
 /**
@@ -65,16 +58,20 @@ export declare function cappedWaterFill(vals: number[], indices: number[], pool:
  */
 export declare function normalizeWeekToCapacity(allocations: Record<string, number>, categories: CapacityCategory[], { capacity, maxHourPerCell }: CapacityConstraints): Record<string, number>;
 /**
- * Proportional rebalance for a drag on EFFECTIVE band `catIndex` (the reals
- * followed by the synthetic Unavailable band). Grows/shrinks the grabbed band
- * by the drag distance (`deltaHours`) and distributes the inverse change across
- * the other bands — INCLUDING Unavailable — in proportion to their drag-start
- * snapshot, never below FLOOR and never above `maxHourPerCell` (Unavailable is
- * uncapped). The total is always exactly C. Implemented as a capped water-fill:
- * the surplus from any band that hits its cap spills onto the uncapped bands.
+ * Independent edit of ONE real category on EFFECTIVE band `catIndex` (the reals
+ * followed by the synthetic Unavailable band). Only the edited band and
+ * Unavailable change; every other band is returned exactly as it was in `snap`.
+ *
+ * - An increase takes only spare hours (what Unavailable holds), up to the
+ *   band's cap (`maxHourPerCell`).
+ * - A decrease returns the hours to Unavailable. An active band (≥ FLOOR)
+ *   bottoms at FLOOR, and a result in (0, FLOOR) snaps to 0.
+ * - Data already over the cap or over capacity can shrink but never grow.
+ * - Editing Unavailable itself returns the snapshot unchanged.
  *
- * `snap` is the FULL effective snapshot (reals + Unavailable, Unavailable last).
+ * `snap` is the FULL effective snapshot (reals + Unavailable, Unavailable last);
+ * its values are ≥ 0.
  */
-export declare function rebalance(snap: number[], catIndex: number, deltaHours: number, { capacity, maxHourPerCell }: CapacityConstraints): number[];
+export declare function adjustBand(snap: number[], catIndex: number, deltaHours: number, { capacity, maxHourPerCell }: CapacityConstraints): number[];
 /** Stable deterministic palette color for a category with no explicit color. */
 export declare function colorForCategory(id: string, index: number): string;

package/library/packages/organisms/src/capacity-planner/capacity-planner.d.ts

@@ -13,20 +13,19 @@ export type CapacityEditMode = 'adjust' | 'copy';
 /**
  * @summary Individual weekly capacity planner. Each week distributes a fixed
  * weekly capacity across work categories as a horizontal bar of colored bands.
- * Users either drag a band to rebalance the split or copy whole weeks across a
- * range. A reserved, component-synthesized "Unavailable" (grey) band fills
- * each week up to the weekly capacity, so the UI total is ALWAYS exactly the
- * capacity while the REAL categories may sum to LESS. Dragging any band
- * (including Unavailable) rebalances proportionally against the others; an
- * empty week renders as 100% Unavailable with the real bands at 0 shown as
- * grabbable FLOOR-width slivers. Hours are floats internally and rounded only
- * for display/save. The Unavailable band is NEVER saved: edits emit a
- * debounced `cx-capacity-change` carrying ONLY the real categories for each
- * edited week, with integer hours (largest-remainder) that sum to
- * round(capacity) − round(unavailable) and match the visible labels.
- * Read `currentWeeks` to save the complete live allocation snapshot immediately,
- * including edits whose change event has not emitted yet. Untouched weeks keep
- * their original fractional hours; edited weeks match the integer labels.
+ * Users either drag (or arrow-key) a category band to change its hours or copy
+ * whole weeks across a range. A reserved, component-synthesized "Unavailable"
+ * (grey) band fills each week up to the weekly capacity, so the UI total is
+ * ALWAYS exactly the capacity while the REAL categories may sum to LESS.
+ * Editing one category only moves that category and Unavailable, which is
+ * derived and cannot be edited. Hours are rounded for display/save. The
+ * Unavailable band is NEVER saved: edits emit a debounced `cx-capacity-change`
+ * carrying ONLY the real categories for each edited week, with integer hours
+ * (largest-remainder) that sum to round(capacity) − round(unavailable) and
+ * match the visible labels. Read `currentWeeks` to save the complete live
+ * allocation snapshot immediately, including edits whose change event has not
+ * emitted yet. Untouched weeks keep their original fractional hours; edited
+ * weeks match the integer labels.
  *
  * @event {{ weeks: Array<{ weekStart: string, allocations: Array<{ categoryId: string, hours: number }> }> }} cx-capacity-change - Debounced (~1000ms) emit of every edited week's REAL category allocations (integer hours; the unallocated remainder is implicit and the synthetic Unavailable band is never included).
  */
@@ -64,8 +63,11 @@ export default class CxCapacityPlanner extends CortexElement {
     private filling;
     private fillToW;
     private copyMsg;
+    /** Measured width of a week bar (px); a fallback for the bars' own sizing. */
     private barWidth;
     private readonly scrollEl;
+    /** The first week bar; every week bar has the same width. */
+    private readonly rowBarEl;
     /**
      * Live plan: plan[weekIndex] = { categoryId -> hours } as floats. This is a
      * plain field (not reactive) because it mutates many times per drag frame; we
@@ -86,6 +88,7 @@ export default class CxCapacityPlanner extends CortexElement {
     constructor();
     runConnectedCallback(): void;
     disconnectedCallback(): void;
+    runFirstUpdated(): void;
     /**
      * Detached snapshot of all weeks, available synchronously before and after
      * `cx-capacity-change`. Edited weeks use the same integer hours as that event;
@@ -140,17 +143,31 @@ export default class CxCapacityPlanner extends CortexElement {
      */
     private get capacityConstraints();
     private clamp;
-    private correctToCapacity;
     private effectiveCapFor;
     private cappedWaterFill;
     private normalizeWeekToCapacity;
-    private rebalance;
+    private adjustBand;
+    /** Live float hours of a week over the effective set (reals + Unavailable). */
+    private weekValues;
+    /**
+     * Starting point for a band edit: the week snapped to its DISPLAYED integers
+     * (reals = the largest-remainder labels, Unavailable = C − Σreals). Editing
+     * one category then only moves that category and Unavailable, so leftover
+     * fractions in legacy data cannot flip the label of another category.
+     */
+    private editSnapshot;
     private writeWeek;
     private copyWeek;
     private markDirty;
     private scheduleEmit;
     private emitChange;
     private scheduleRender;
+    /**
+     * Cache the real width of a week bar as the `bar-width` fallback. The bars
+     * size their bands in CSS and measure themselves, and a drag snapshots the
+     * live bar width on pointer-down, so this value only matters before a bar
+     * has measured itself.
+     */
     private measure;
     private handleResize;
     private bandsForWeek;
@@ -158,10 +175,15 @@ export default class CxCapacityPlanner extends CortexElement {
     /** Read the week index from the `data-week-index` attr on the event target. */
     private weekIndexFromEvent;
     private handleBandPointerDown;
-    /** Keyboard step on a band — routed through the SAME rebalance + emit. */
+    /** Keyboard step on a band — routed through the SAME adjustBand + emit. */
     private handleBandStep;
     private handlePointerMove;
     private handlePointerUp;
+    /**
+     * Snap a dragged week to the whole hours its labels show; keyboard edits
+     * already are.
+     */
+    private snapWeekToLabels;
     private weekFromY;
     private handleScrollPointerDown;
     private handleFillPointerDown;

package/library/packages/organisms/src/capacity-planner/components/capacity-week-bar/capacity-week-bar.d.ts

@@ -12,7 +12,12 @@ export interface CapacityBand {
     categoryName: string;
     /** Background color (already resolved to a concrete CSS color). */
     color: string;
-    /** Hours for this band — used as the flex-grow weight and aria-valuenow. */
+    /**
+     * Hours derived from the other bands (the synthetic "Unavailable" band): never
+     * a slider, even on a `resizable` bar, and it fills whatever the others leave.
+     */
+    derived?: boolean;
+    /** Hours for this band; a real band is `hours / capacity` of the bar wide. */
     hours: number;
     /** Full label text, e.g. "12h · Reviews". */
     label: string;
@@ -20,21 +25,24 @@ export interface CapacityBand {
     shortLabel: string;
     /** Tooltip text, e.g. "Reviews · 12h" (set when no inline label fits). */
     tip: string;
-    /**
-     * When true the band ignores `maxHourPerCell` for its slider ceiling (used by
-     * the synthetic "Unavailable" band, which is uncapped). Optional; defaults
-     * to capped behaviour.
-     */
-    uncapped?: boolean;
 }
 /**
- * @summary Presentational capacity bar: a flex row of category bands sized by
- * hours. All mutation/allocation logic lives in the `cx-capacity-planner`
- * container — this component only renders bands and forwards pointer/keyboard
- * intent. When `resizable`, bands are exposed as ARIA sliders (keyboard +
- * screen-reader accessible, mirroring `cx-range`). Every week always has bands
- * (the container synthesizes a grey "Unavailable" band that fills the week up
- * to capacity), so there is no empty/unplanned track to special-case.
+ * @summary Presentational capacity bar: a row of category bands on a FIXED
+ * scale. A real band is exactly `hours / capacity` of the bar wide, so the same
+ * hours give the same length in every week and at every position; a `derived`
+ * band (the grey "Unavailable" band the container synthesizes) fills the rest
+ * and shrinks to nothing when the week is full. All mutation/allocation logic
+ * lives in the `cx-capacity-planner` container — this component only renders
+ * bands and forwards pointer/keyboard intent. When `resizable`, real bands are
+ * exposed as ARIA sliders (mirroring `cx-range`); a 0-hour one stays focusable
+ * and is grabbed through a small handle outside the flow. Data over the
+ * capacity is clipped at the right edge, marked with a thin danger-coloured
+ * line.
+ *
+ * @cssproperty [--cx-capacity-bar-height=22px] - Height of the bar.
+ * @cssproperty [--cx-capacity-bar-radius=6px] - Corner radius of the bar.
+ * @cssproperty --cx-capacity-track-bg - Background of the track behind the bands.
+ * @cssproperty [--cx-capacity-zero-handle-width=10px] - Width of the grab handle shown for a 0-hour band.
  *
  * @event {{ barWidth: number, categoryId: string, pointerEvent: PointerEvent }} cx-capacity-week-bar-band-pointer-down - Fired when a resizable band is pressed.
  * @event {{ categoryId: string, deltaHours: number }} cx-capacity-week-bar-band-step - Fired when a band is stepped via the keyboard.
@@ -50,18 +58,22 @@ export default class CxCapacityWeekBar extends CortexElement {
     barWidth: number;
     /** Total weekly capacity (C). The bands always sum to it (incl. Unavailable). */
     capacity: number;
-    /** Per-band slider floor (lowest hours a band may hold). */
+    /**
+     * Kept for backward compatibility; it no longer affects layout. Band widths
+     * follow the fixed `hours / capacity` scale, and a 0-hour band on a resizable
+     * bar is grabbed through its handle rather than a floor-width sliver.
+     */
     floor: number;
     /** Optional per-band slider ceiling (max hours a single band may hold). */
     maxHourPerCell?: number;
-    /** Whether bands are resizable (drag-to-rebalance / keyboard steppable). */
+    /** Whether non-derived bands are resizable (draggable / keyboard steppable). */
     resizable: boolean;
     /**
-     * When true, a band with 0 hours renders at 0px width (no FLOOR-clamped grab
-     * sliver). For read-only displays (e.g. the team grid's mini-bars) there is no
-     * need for a draggable zone, so a 0-hours category should simply not show.
-     * Defaults false — the resizable planner/zoom bars keep the FLOOR-width grab
-     * sliver so a 0-hours category stays clickable to grow back.
+     * When true, a band with 0 hours is removed from the accessibility tree and
+     * gets no grab handle, so a 0-hours category simply does not show — for
+     * read-only displays (e.g. mini-bars) where there is nothing to drag. Every
+     * 0-hour band is 0px wide either way; defaults false, so on a resizable bar a
+     * 0-hours category keeps its handle and stays grabbable to grow back.
      */
     collapseZeroBands: boolean;
     /** Px width threshold above which the full "{h}h · {name}" label is shown. */
@@ -70,6 +82,11 @@ export default class CxCapacityWeekBar extends CortexElement {
     shortLabelThreshold: number;
     private readonly barEl;
     private summary;
+    /** Hours not held by an editable band: capacity − Σ non-derived hours (≥ 0). */
+    private spareHours;
+    /** True when the editable bands hold more than the capacity (clipped data). */
+    private overCapacity;
+    /** Display geometry of each band, parallel to `bands`. */
     private geometries;
     /** Actual rendered width of the bar element, updated by ResizeObserver. */
     renderedBarWidth: number;
@@ -89,13 +106,21 @@ export default class CxCapacityWeekBar extends CortexElement {
      * `render` so the tip shows/hides in exact sync with the inline label (and so
      * the tip text tracks a band being resized under a captured pointer).
      *
-     * In `collapseZeroBands` (read-only display) mode a 0-hours category renders at
-     * 0px (no grab sliver needed — nothing to drag). Otherwise the DISPLAY width is
-     * clamped to a FLOOR-equivalent minimum so a category at 0 (or below FLOOR)
-     * still renders as a grabbable band, while its label/saved value stay the true
-     * (quantized) hours.
+     * Every band is on the same fixed scale, so the label thresholds see the
+     * band's real width. A real 0-hour band on a resizable bar is `zero` (0px,
+     * grabbed through its handle); in `collapseZeroBands` mode a 0-hour band is
+     * `collapsed` instead.
      */
     private bandGeometry;
+    /**
+     * Place the handle of every `zero` band, writing `zeroIndex` / `zeroAtEnd`
+     * into `geometries`. Consecutive 0-hour handles would all sit on the same
+     * spot, so each run of them gets increasing indices and the handles are laid
+     * side by side. A run that starts at (or past) the right edge of the bar is
+     * drawn leftwards instead, so the edge does not clip it. Bands that take no
+     * width (other 0-hour bands) do not break a run.
+     */
+    private placeZeroHandles;
     private renderBand;
     render(): TemplateResult;
 }

package/library/packages/organisms/src/comment/comment.d.ts

@@ -179,6 +179,11 @@ export default class CxComment<TCommentMenu extends CxCommentMenu = CxCommentMen
     private handleCommentMousedown;
     handleEditableChange(): void;
     handlePlaceholderChange(): void;
+    /**
+     * Element focused when fullscreen was entered. Moving the container into the
+     * dialog blurs it, so the dialog itself only ever captures the body.
+     */
+    private fullscreenTrigger;
     handleFullscreenChange(): void;
     private handleRequestClose;
     protected renderMenu(): TemplateResult | DirectiveResult<typeof GuardDirective>;

package/library/packages/organisms/src/content-builder/configs/dam-view-panel-options.d.ts

@@ -0,0 +1,12 @@
+import { GetDamViewAvailablePanelsResponse } from '../../../../services/src/api/cms5/cms5.types';
+import { Option } from '../../../../types/src/content-builder';
+/** A single side panel returned by the DAM view available-panels endpoint. */
+export type DamViewPanel = GetDamViewAvailablePanelsResponse[number];
+/**
+ * Reference id of the built-in "Standard Filters" side panel (`DamView_BO.Const.SIDE_PANEL_ID_FILTERS`).
+ * It is the default workspace filter button flavor and the DAM view's last-resort fallback for an
+ * empty or invalid one.
+ */
+export declare const STANDARD_FILTERS_PANEL_ID = "OR1ND000001072386";
+/** Maps a DAM view side panel to a table-select option (name, description, security point). */
+export declare function toPanelOption(panel: DamViewPanel): Option;

package/library/packages/organisms/src/space-selector/space-selector.d.ts

@@ -22,6 +22,8 @@ import { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';
  *
  * @slot (default) - Entries the host renders above the space list, e.g. a drawer's "Back" item.
  *
+ * @csspart trigger - The trigger, a `cx-icon-button` or a `cx-button` depending on `trigger-variant`.
+ * @csspart trigger-base - The trigger's own `base` part, which carries its colour in every state. *
  * @event cx-space-select - The user picked a different space. Detail carries its module and URL.
  * @event cx-space-create - The user asked for a new space.
  * @event cx-space-settings - The user asked for the current space's settings.

package/library/packages/services/src/api/cms5/cms5.d.ts

@@ -50,6 +50,7 @@ export declare function apiGetDamViewAssetStatuses(): Promise<GetDamViewAssetSta
 export declare function apiGetDamViewAssetTypes(): Promise<GetDamViewAssetTypesResponse>;
 export declare function apiGetDamViewAvailablePanels(params?: {
     additionalFilterOnly?: boolean;
+    includeStandardFilters?: boolean;
 }): Promise<GetDamViewAvailablePanelsResponse>;
 export declare function apiGetDamViewDisplayModeOptions(): Promise<GetDamViewDisplayModeOptionsResponse>;
 export declare function apiGetDamViewAvailableTemplates(): Promise<GetDamViewAvailableTemplatesResponse>;

package/library/react-web-component.d.ts

@@ -8446,7 +8446,7 @@
         preRender?: boolean;
             }
             /**
-              * Individual weekly capacity planner. Each week distributes a fixed weekly capacity across work categories as a horizontal bar of colored bands. Users either drag a band to rebalance the split or copy whole weeks across a range. A reserved, component-synthesized "Unavailable" (grey) band fills each week up to the weekly capacity, so the UI total is ALWAYS exactly the capacity while the REAL categories may sum to LESS. Dragging any band (including Unavailable) rebalances proportionally against the others; an empty week renders as 100% Unavailable with the real bands at 0 shown as grabbable FLOOR-width slivers. Hours are floats internally and rounded only for display/save. The Unavailable band is NEVER saved: edits emit a debounced `cx-capacity-change` carrying ONLY the real categories for each edited week, with integer hours (largest-remainder) that sum to round(capacity) − round(unavailable) and match the visible labels. Read `currentWeeks` to save the complete live allocation snapshot immediately, including edits whose change event has not emitted yet. Untouched weeks keep their original fractional hours; edited weeks match the integer labels.
+              * Individual weekly capacity planner. Each week distributes a fixed weekly capacity across work categories as a horizontal bar of colored bands. Users either drag (or arrow-key) a category band to change its hours or copy whole weeks across a range. A reserved, component-synthesized "Unavailable" (grey) band fills each week up to the weekly capacity, so the UI total is ALWAYS exactly the capacity while the REAL categories may sum to LESS. Editing one category only moves that category and Unavailable, which is derived and cannot be edited. Hours are rounded for display/save. The Unavailable band is NEVER saved: edits emit a debounced `cx-capacity-change` carrying ONLY the real categories for each edited week, with integer hours (largest-remainder) that sum to round(capacity) − round(unavailable) and match the visible labels. Read `currentWeeks` to save the complete live allocation snapshot immediately, including edits whose change event has not emitted yet. Untouched weeks keep their original fractional hours; edited weeks match the integer labels.
             */
             interface CxCapacityPlannerAttributes extends HTMLAttributes<CxCapacityPlanner> {
               

package/library/utils.js

@@ -1,6 +1,6 @@
 import { a as e, i as t, n, o as r, r as i, t as a } from "./chunks/event.C11S4obG.js";
 import { t as o } from "./chunks/custom-element.BEMYNDK1.js";
-import { r as s, t as c } from "./chunks/i18n.CpiuF-f4.js";
+import { r as s, t as c } from "./chunks/i18n.BMXeDUpk.js";
 import { n as l, r as u, t as d } from "./chunks/slot.CZUlACxT.js";
 import { t as f } from "./chunks/watch.Ub5r8btz.js";
 import { C as p, S as m, _ as h, a as g, b as _, c as ee, d as te, f as ne, g as re, h as ie, i as ae, l as oe, m as se, n as ce, o as le, p as ue, r as de, s as fe, t as pe, u as me, v as he, w as ge, x as _e, y as ve } from "./chunks/string.DamEXDH2.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orangelogic/design-system",
   "type": "module",
-  "version": "4.23.0",
+  "version": "4.24.0",
   "license": "UNLICENSED",
   "types": "library/types.d.ts",
   "scripts": {