@pilotiq/pilotiq 0.2.0 → 0.3.0

package/src/schema/Alert.ts

@@ -1,11 +1,24 @@
 import { Element } from './Element.js'
 import type { Action } from '../actions/Action.js'
+import type { IconColor } from './Icon.js'
 
 export type AlertType = 'info' | 'warning' | 'success' | 'danger'
 
+/**
+ * Alignment for the footer-actions row inside an `Alert` (Filament v5
+ * parity). `'start'` aligns the buttons to the leading edge (LTR =
+ * left), `'center'` to the middle, `'end'` to the trailing edge (LTR =
+ * right). Defaults to `'start'`.
+ */
+export type AlertActionsAlignment = 'start' | 'center' | 'end'
+
 export class Alert extends Element {
-  private _alertType: AlertType = 'info'
-  private _title?: string
+  private _alertType:        AlertType = 'info'
+  private _title?:           string
+  private _dismissible       = false
+  private _persistKey?:      string
+  private _iconColor?:       IconColor
+  private _actionsAlignment: AlertActionsAlignment = 'start'
 
   private constructor(private content: string) {
     super()
@@ -16,12 +29,12 @@ export class Alert extends Element {
   }
 
   alertType(t: AlertType): this { this._alertType = t; return this }
-  title(t: string): this { this._title = t; return this }
+  title(t: string):        this { this._title     = t; return this }
 
-  info(): this { return this.alertType('info') }
+  info():    this { return this.alertType('info')    }
   warning(): this { return this.alertType('warning') }
   success(): this { return this.alertType('success') }
-  danger(): this { return this.alertType('danger') }
+  danger():  this { return this.alertType('danger')  }
 
   /**
    * Action buttons rendered as a footer row below the alert body —
@@ -36,14 +49,83 @@ export class Alert extends Element {
     return this
   }
 
+  /** Filament v5 parity alias for `actions([...])`. Identical semantics. */
+  controls(actions: Action[]): this {
+    return this.actions(actions)
+  }
+
+  /**
+   * Filament v5 parity — variadic `controlActions(a, b, c, …)` matches
+   * the spread shape `controlActions(Action::make(...), Action::make(...))`.
+   */
+  controlActions(...actions: Action[]): this {
+    return this.actions(actions)
+  }
+
+  /**
+   * Toggle the close (`×`) button rendered in the alert's top-right
+   * corner. Off by default (matches today's behaviour). Dismissal is
+   * per-mount (component-local state) unless paired with
+   * `persistDismissal(key)`, which writes to `localStorage` so the
+   * alert stays hidden across reloads.
+   *
+   * @example
+   *   Alert.make('Heads up — billing downgrades on Friday.')
+   *     .warning()
+   *     .dismissible()
+   *     .persistDismissal('billing-downgrade-2026-q2')
+   */
+  dismissible(value: boolean = true): this {
+    this._dismissible = value
+    return this
+  }
+
+  /**
+   * Persist dismissal under a stable localStorage key. Auto-arms
+   * `dismissible(true)` so the close button shows up. The key is
+   * stored under `pilotiq.alert.<key>` to namespace from other
+   * pilotiq localStorage entries; users only see the leaf segment.
+   */
+  persistDismissal(key: string): this {
+    this._persistKey  = key
+    this._dismissible = true
+    return this
+  }
+
+  /**
+   * Override the icon color independent of the alert type. By default
+   * the renderer picks an icon hue matching `alertType`
+   * (info/warning/success/danger); call this to force a different one
+   * — e.g. a `warning`-typed alert with a `'destructive'` icon when
+   * the message escalates partway through a flow.
+   */
+  iconColor(color: IconColor): this {
+    this._iconColor = color
+    return this
+  }
+
+  /**
+   * Align the footer actions row. Defaults to `'start'` (LTR-left).
+   * Use `'end'` for "primary action sits opposite the close button"
+   * layouts; `'center'` for short single-button alerts.
+   */
+  footerActionsAlignment(alignment: AlertActionsAlignment): this {
+    this._actionsAlignment = alignment
+    return this
+  }
+
   getType(): string { return 'alert' }
 
   toMeta() {
     return {
-      type: 'alert' as const,
-      content: this.content,
+      type:      'alert' as const,
+      content:   this.content,
       alertType: this._alertType,
-      ...(this._title ? { title: this._title } : {}),
+      ...(this._title             !== undefined ? { title:             this._title             } : {}),
+      ...(this._dismissible                     ? { dismissible:       true                    } : {}),
+      ...(this._persistKey        !== undefined ? { persistDismissal:  this._persistKey        } : {}),
+      ...(this._iconColor         !== undefined ? { iconColor:         this._iconColor         } : {}),
+      ...(this._actionsAlignment !== 'start'    ? { actionsAlignment:  this._actionsAlignment  } : {}),
     }
   }
 }

package/src/schema/resolveSchema.ts

@@ -22,6 +22,7 @@ import {
   type RepeatableEntryRowMeta,
 } from '../entries/RepeatableEntry.js'
 import { Section } from './Section.js'
+import { TextField } from '../fields/TextField.js'
 
 export interface SchemaContext {
   user?: { name?: string; email?: string; [key: string]: unknown }
@@ -321,6 +322,37 @@ async function resolveOne(el: Element, ctx: RenderContext): Promise<ElementMeta
     }
   }
 
+  // Filament v5 — `Action.modalContentFooter([Element…])` resolves through
+  // the standard walker so any inner Actions evaluate `.visible() /
+  // .disabled()` the same way as anywhere else, and non-Action chrome
+  // (Alert / Text / Heading / …) flows through the same rendering path.
+  // Stamped under `meta.modalContentFooter` so the renderer can mount it
+  // between the form body and the Cancel/Submit footer.
+  if (el instanceof Action) {
+    const footer = el.getModalContentFooter()
+    if (footer && footer.length > 0) {
+      meta['modalContentFooter'] = await resolveAll(footer, ctx)
+    }
+  }
+
+  // `TextField.prefixAction(Action) / suffixAction(Action)` — resolve the
+  // bound Actions through `resolveAll` so visibility / disabled rules
+  // evaluate the same way as anywhere else. Hidden Actions are dropped
+  // from the slot (returning a sparse single-element array → undefined
+  // collapses cleanly).
+  if (el instanceof TextField) {
+    const pre  = el.getPrefixAction()
+    const suf  = el.getSuffixAction()
+    if (pre) {
+      const [resolved] = await resolveAll([pre], ctx)
+      if (resolved) meta['prefixAction'] = resolved
+    }
+    if (suf) {
+      const [resolved] = await resolveAll([suf], ctx)
+      if (resolved) meta['suffixAction'] = resolved
+    }
+  }
+
   return meta
 }