@masmarino/gabarit 2.0.0 → 2.1.1

package/types/masmarino-gabarit-chart.d.ts

@@ -0,0 +1,361 @@
+import * as i0 from "@angular/core";
+import { InjectionToken, Signal } from "@angular/core";
+interface Tick {
+  key: string;
+  x: number;
+  y: number;
+  label: string;
+  date: string | null;
+  anchor: 'start' | 'middle' | 'end';
+}
+export declare class ChartAxis {
+  private readonly context;
+  axis: import("@angular/core").InputSignal<"x" | "y">;
+  locale: import("@angular/core").InputSignal<string>;
+  tickCount: import("@angular/core").InputSignal<number>;
+  format: import("@angular/core").InputSignal<((value: never) => string) | null>;
+  grid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly groupTransform: import("@angular/core").Signal<string>;
+  protected readonly ticks: import("@angular/core").Signal<Tick[]>;
+  protected readonly gridLines: import("@angular/core").Signal<number[]>;
+  protected readonly innerWidth: import("@angular/core").Signal<number>;
+  private yTicks;
+  private xTicks;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ChartAxis, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ChartAxis, "g[gbtChartAxis]", never, {
+    "axis": {
+      "alias": "axis";
+      "required": true;
+      "isSignal": true;
+    };
+    "locale": {
+      "alias": "locale";
+      "required": true;
+      "isSignal": true;
+    };
+    "tickCount": {
+      "alias": "tickCount";
+      "required": false;
+      "isSignal": true;
+    };
+    "format": {
+      "alias": "format";
+      "required": false;
+      "isSignal": true;
+    };
+    "grid": {
+      "alias": "grid";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+interface Scale<T> {
+  map(value: T): number;
+  invert(pixel: number): T;
+  readonly domain: [T, T];
+  readonly range: [number, number];
+}
+export declare function linearScale(domain: [number, number], range: [number, number]): Scale<number>;
+export declare function timeScale(domain: [Date, Date], range: [number, number]): Scale<Date>;
+interface BandScale {
+  map(value: string): number;
+  invert(pixel: number): string | null;
+  readonly bandwidth: number;
+  readonly domain: string[];
+  readonly range: [number, number];
+}
+export declare function bandScale(domain: string[], range: [number, number], padding?: number): BandScale;
+interface ChartMargin {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+}
+interface ChartBox {
+  readonly width: number;
+  readonly height: number;
+  readonly margin: ChartMargin;
+  readonly innerWidth: number;
+  readonly innerHeight: number;
+}
+type LinearAxisSpec = {
+  kind: 'linear';
+  domain: [number, number];
+};
+type PointValue = number | Date | string;
+type AxisSpec = LinearAxisSpec | {
+  kind: 'time';
+  domain: [Date, Date];
+} | {
+  kind: 'band';
+  domain: string[];
+  padding?: number;
+};
+interface ChartReader {
+  readonly box: Signal<ChartBox>;
+  readonly xSpec: Signal<AxisSpec>;
+  readonly ySpec: Signal<LinearAxisSpec>;
+  readonly xScale: Signal<Scale<number> | Scale<Date> | BandScale>;
+  readonly yScale: Signal<Scale<number>>;
+  readonly activeIndex: Signal<number | null>;
+  readonly pointValues: Signal<PointValue[]>;
+  readonly activePosition: Signal<number | null>;
+}
+export declare const CHART_CONTEXT: InjectionToken<ChartReader>;
+declare class ChartContext implements ChartReader {
+  private readonly _box;
+  private readonly _xSpec;
+  private readonly _ySpec;
+  private readonly _activeIndex;
+  private readonly _pointValues;
+  readonly box: Signal<ChartBox>;
+  readonly xSpec: Signal<AxisSpec>;
+  readonly ySpec: Signal<LinearAxisSpec>;
+  readonly activeIndex: Signal<number | null>;
+  readonly pointValues: Signal<PointValue[]>;
+  readonly xScale: Signal<Scale<number> | Scale<Date> | BandScale>;
+  readonly yScale: Signal<Scale<number>>;
+  readonly pointPositions: Signal<number[]>;
+  readonly activePosition: Signal<number | null>;
+  setPointValues(values: PointValue[]): void;
+  setGeometry(box: ChartBox): void;
+  setSpecs(x: AxisSpec, y: LinearAxisSpec): void;
+  setActiveIndex(index: number | null): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ChartContext, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+interface ChartPoint<X> {
+  x: X;
+  y: number;
+  display?: string;
+}
+interface ChartSeries<X> {
+  label: string;
+  points: ChartPoint<X>[];
+  pattern?: 'solid' | 'dashed' | 'dotted';
+}
+interface ChartInterval {
+  start: Date;
+  end: Date;
+  label: string;
+}
+declare function yDomain<X>(series: ChartSeries<X>[], includeZero: boolean): [number, number];
+declare function numericXDomain(series: ChartSeries<number>[]): [number, number];
+export declare function timeXDomain(series: ChartSeries<Date>[]): [Date, Date];
+declare function longestSeriesLength<X>(series: ChartSeries<X>[]): number;
+export declare function niceYDomain<X>(series: ChartSeries<X>[], includeZero: boolean, tickCount: number): [number, number];
+export declare function niceXDomain(series: ChartSeries<number>[], tickCount: number): [number, number];
+export declare class ChartEmpty {
+  message: import("@angular/core").InputSignal<string>;
+  actionLabel: import("@angular/core").InputSignal<string>;
+  action: import("@angular/core").OutputEmitterRef<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ChartEmpty, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ChartEmpty, "gbt-chart-empty", never, {
+    "message": {
+      "alias": "message";
+      "required": true;
+      "isSignal": true;
+    };
+    "actionLabel": {
+      "alias": "actionLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "action": "action";
+  }, never, ["[gbtChartEmptyIcon]"], true, never>;
+}
+export declare class ChartFrame {
+  private readonly context;
+  label: import("@angular/core").InputSignal<string>;
+  heading: import("@angular/core").InputSignal<string>;
+  headingLevel: import("@angular/core").InputSignal<2 | 1 | 5 | 3 | 6 | 4>;
+  headline: import("@angular/core").InputSignal<string>;
+  trend: import("@angular/core").InputSignal<string>;
+  x: import("@angular/core").InputSignal<AxisSpec>;
+  y: import("@angular/core").InputSignal<LinearAxisSpec>;
+  margin: import("@angular/core").InputSignal<Partial<ChartMargin>>;
+  size: import("@angular/core").InputSignal<{
+    width: number;
+    height: number;
+  } | null>;
+  pointValues: import("@angular/core").InputSignal<PointValue[]>;
+  readonly activeIndexChange: import("@angular/core").OutputEmitterRef<number | null>;
+  private readonly surface;
+  private readonly measured;
+  protected readonly ready: import("@angular/core").Signal<boolean>;
+  protected readonly viewBox: import("@angular/core").Signal<string>;
+  protected readonly innerTransform: import("@angular/core").Signal<string>;
+  protected readonly activePosition: import("@angular/core").Signal<number | null>;
+  protected readonly innerHeight: import("@angular/core").Signal<number>;
+  constructor();
+  protected onKeydown(event: KeyboardEvent): void;
+  protected onBlur(): void;
+  protected onPointerMove(event: PointerEvent | MouseEvent): void;
+  protected onPointerLeave(event: PointerEvent | MouseEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ChartFrame, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ChartFrame, "gbt-chart-frame", never, {
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "heading": {
+      "alias": "heading";
+      "required": false;
+      "isSignal": true;
+    };
+    "headingLevel": {
+      "alias": "headingLevel";
+      "required": false;
+      "isSignal": true;
+    };
+    "headline": {
+      "alias": "headline";
+      "required": false;
+      "isSignal": true;
+    };
+    "trend": {
+      "alias": "trend";
+      "required": false;
+      "isSignal": true;
+    };
+    "x": {
+      "alias": "x";
+      "required": true;
+      "isSignal": true;
+    };
+    "y": {
+      "alias": "y";
+      "required": true;
+      "isSignal": true;
+    };
+    "margin": {
+      "alias": "margin";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "pointValues": {
+      "alias": "pointValues";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "activeIndexChange": "activeIndexChange";
+  }, never, ["[gbtChartLayer]", "gbt-chart-tooltip", "gbt-chart-empty", "gbt-chart-table"], true, never>;
+}
+interface LegendEntry {
+  label: string;
+  pattern?: 'solid' | 'dashed' | 'dotted';
+  color?: string;
+  value?: string;
+}
+export declare class ChartLegend {
+  entries: import("@angular/core").InputSignal<LegendEntry[]>;
+  interactive: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  activeIndex: import("@angular/core").InputSignal<number | null>;
+  activeIndexChange: import("@angular/core").OutputEmitterRef<number | null>;
+  protected dashArray(pattern: LegendEntry['pattern']): string;
+  protected onMouseLeave(event: MouseEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ChartLegend, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ChartLegend, "gbt-chart-legend", never, {
+    "entries": {
+      "alias": "entries";
+      "required": true;
+      "isSignal": true;
+    };
+    "interactive": {
+      "alias": "interactive";
+      "required": false;
+      "isSignal": true;
+    };
+    "activeIndex": {
+      "alias": "activeIndex";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "activeIndexChange": "activeIndexChange";
+  }, never, never, true, never>;
+}
+export declare class ChartTable {
+  caption: import("@angular/core").InputSignal<string>;
+  columns: import("@angular/core").InputSignal<string[]>;
+  rows: import("@angular/core").InputSignal<(string | number)[][]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ChartTable, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ChartTable, "gbt-chart-table", never, {
+    "caption": {
+      "alias": "caption";
+      "required": true;
+      "isSignal": true;
+    };
+    "columns": {
+      "alias": "columns";
+      "required": true;
+      "isSignal": true;
+    };
+    "rows": {
+      "alias": "rows";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+interface TooltipRow {
+  label: string;
+  value: string;
+  series?: 1 | 2 | 3;
+  pattern?: 'solid' | 'dashed' | 'dotted';
+}
+interface TooltipPoint<X> {
+  x: X;
+  header: string;
+  rows: TooltipRow[];
+}
+export declare class ChartTooltip<X> {
+  private readonly context;
+  points: import("@angular/core").InputSignal<TooltipPoint<X>[]>;
+  protected readonly active: import("@angular/core").Signal<TooltipPoint<X> | null>;
+  protected readonly left: import("@angular/core").Signal<number>;
+  protected readonly anchor: import("@angular/core").Signal<"start" | "middle" | "end">;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ChartTooltip<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ChartTooltip<any>, "gbt-chart-tooltip", never, {
+    "points": {
+      "alias": "points";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+declare const ESTIMATED_CHAR_WIDTH = 6.5;
+declare const LABEL_GAP = 8;
+export declare function estimateLabelWidth(label: string): number;
+export declare function nearestIndex(sorted: number[], target: number): number;
+interface Point {
+  x: number;
+  y: number;
+}
+export declare function linePath(points: Point[]): string;
+export declare function areaPath(points: Point[], baseline: number): string;
+interface Arc {
+  startAngle: number;
+  endAngle: number;
+  innerRadius: number;
+  outerRadius: number;
+}
+export declare function arcPath(arc: Arc): string;
+export declare function niceTicks(min: number, max: number, count: number): number[];
+type TimeUnit = 'second' | 'minute' | 'hour' | 'day' | 'month' | 'year';
+interface TimeTicks {
+  readonly values: Date[];
+  readonly unit: TimeUnit;
+  format(date: Date, locale: string): string;
+}
+export declare function timeTicks(start: Date, end: Date, pixelWidth: number): TimeTicks;
+export type { Arc, AxisSpec, BandScale, ChartBox, ChartInterval, ChartMargin, ChartPoint, ChartReader, ChartSeries, LegendEntry, LinearAxisSpec, Point, PointValue, Scale, TimeTicks, TimeUnit, TooltipPoint, TooltipRow };

package/types/masmarino-gabarit-checkbox-group.d.ts

@@ -0,0 +1,113 @@
+import { ControlValueAccessor } from "@angular/forms";
+import * as i0 from "@angular/core";
+interface CheckboxGroupOption<T = string> {
+  value: T;
+  label: string;
+  hint?: string;
+  disabled?: boolean;
+}
+interface CheckboxGroupSection<T = string> {
+  label: string;
+  options: CheckboxGroupOption<T>[];
+}
+interface RenderedItem<T> {
+  id: string;
+  option: CheckboxGroupOption<T>;
+}
+interface RenderedSection<T> {
+  key: string;
+  label: string | null;
+  labelId: string;
+  items: RenderedItem<T>[];
+}
+export declare class CheckboxGroup<T = string> implements ControlValueAccessor {
+  id: import("@angular/core").InputSignal<string>;
+  legend: import("@angular/core").InputSignal<string>;
+  hideLegend: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  options: import("@angular/core").InputSignal<CheckboxGroupOption<T>[]>;
+  groups: import("@angular/core").InputSignal<CheckboxGroupSection<T>[]>;
+  columns: import("@angular/core").InputSignal<number | "auto">;
+  disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  hint: import("@angular/core").InputSignal<string>;
+  errorMessage: import("@angular/core").InputSignal<string | null>;
+  value: import("@angular/core").ModelSignal<T[]>;
+  private readonly formDisabled;
+  protected readonly isDisabled: import("@angular/core").Signal<boolean>;
+  protected readonly hintId: import("@angular/core").Signal<string>;
+  protected readonly errorId: import("@angular/core").Signal<string>;
+  protected readonly showHint: import("@angular/core").Signal<boolean>;
+  protected readonly describedBy: import("@angular/core").Signal<string | null>;
+  protected readonly sections: import("@angular/core").Signal<RenderedSection<T>[]>;
+  protected readonly sectioned: import("@angular/core").Signal<boolean>;
+  protected readonly gridColumns: import("@angular/core").Signal<string | null>;
+  private onChange;
+  private onTouched;
+  writeValue(value: T[] | null): void;
+  registerOnChange(fn: (value: T[]) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  protected isChecked(value: T): boolean;
+  protected setChecked(value: T, checked: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxGroup<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxGroup<any>, "gbt-checkbox-group", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "legend": {
+      "alias": "legend";
+      "required": true;
+      "isSignal": true;
+    };
+    "hideLegend": {
+      "alias": "hideLegend";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": false;
+      "isSignal": true;
+    };
+    "groups": {
+      "alias": "groups";
+      "required": false;
+      "isSignal": true;
+    };
+    "columns": {
+      "alias": "columns";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "hint": {
+      "alias": "hint";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorMessage": {
+      "alias": "errorMessage";
+      "required": false;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, never, true, never>;
+}
+export type { CheckboxGroupOption, CheckboxGroupSection };

package/types/masmarino-gabarit-checkbox.d.ts

@@ -0,0 +1,49 @@
+import { ControlValueAccessor } from "@angular/forms";
+import * as i0 from "@angular/core";
+export declare class Checkbox implements ControlValueAccessor {
+  id: import("@angular/core").InputSignal<string>;
+  label: import("@angular/core").InputSignal<string>;
+  disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  hint: import("@angular/core").InputSignal<string>;
+  checked: import("@angular/core").ModelSignal<boolean>;
+  protected readonly hintId: import("@angular/core").Signal<string>;
+  private readonly formDisabled;
+  protected readonly isDisabled: import("@angular/core").Signal<boolean>;
+  private onChange;
+  private onTouched;
+  writeValue(value: boolean): void;
+  registerOnChange(fn: (value: boolean) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  protected onToggle(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<Checkbox, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<Checkbox, "gbt-checkbox", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "hint": {
+      "alias": "hint";
+      "required": false;
+      "isSignal": true;
+    };
+    "checked": {
+      "alias": "checked";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "checked": "checkedChange";
+  }, never, never, true, never>;
+}

package/types/masmarino-gabarit-confirm-danger-modal.d.ts

@@ -0,0 +1,94 @@
+import { ButtonVariant } from "@masmarino/gabarit/button";
+import * as i0 from "@angular/core";
+type ConfirmDangerModalTone = 'danger' | 'warning' | 'neutral';
+export declare class ConfirmDangerModal {
+  isOpen: import("@angular/core").InputSignal<boolean>;
+  heading: import("@angular/core").InputSignal<string>;
+  message: import("@angular/core").InputSignal<string>;
+  confirmText: import("@angular/core").InputSignal<string | null | undefined>;
+  confirmInputLabel: import("@angular/core").InputSignal<string>;
+  confirmLabel: import("@angular/core").InputSignal<string>;
+  cancelLabel: import("@angular/core").InputSignal<string>;
+  closeLabel: import("@angular/core").InputSignal<string>;
+  busy: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  busyLabel: import("@angular/core").InputSignal<string>;
+  confirmIcon: import("@angular/core").InputSignal<string | null>;
+  tone: import("@angular/core").InputSignal<ConfirmDangerModalTone>;
+  confirmed: import("@angular/core").OutputEmitterRef<void>;
+  closed: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly typed: import("@angular/core").WritableSignal<string>;
+  protected readonly requiresTyping: import("@angular/core").Signal<boolean>;
+  protected readonly canConfirm: import("@angular/core").Signal<boolean>;
+  protected readonly confirmVariant: import("@angular/core").Signal<ButtonVariant>;
+  protected readonly toneIcon: import("@angular/core").Signal<"info" | "alert-triangle">;
+  constructor();
+  protected confirm(): void;
+  protected cancel(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmDangerModal, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmDangerModal, "gbt-confirm-danger-modal", never, {
+    "isOpen": {
+      "alias": "isOpen";
+      "required": true;
+      "isSignal": true;
+    };
+    "heading": {
+      "alias": "heading";
+      "required": true;
+      "isSignal": true;
+    };
+    "message": {
+      "alias": "message";
+      "required": true;
+      "isSignal": true;
+    };
+    "confirmText": {
+      "alias": "confirmText";
+      "required": false;
+      "isSignal": true;
+    };
+    "confirmInputLabel": {
+      "alias": "confirmInputLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "confirmLabel": {
+      "alias": "confirmLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "cancelLabel": {
+      "alias": "cancelLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeLabel": {
+      "alias": "closeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "busy": {
+      "alias": "busy";
+      "required": false;
+      "isSignal": true;
+    };
+    "busyLabel": {
+      "alias": "busyLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "confirmIcon": {
+      "alias": "confirmIcon";
+      "required": false;
+      "isSignal": true;
+    };
+    "tone": {
+      "alias": "tone";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "confirmed": "confirmed";
+    "closed": "closed";
+  }, never, never, true, never>;
+}
+export type { ConfirmDangerModalTone };