@aotearoan/neon 9.2.8 → 9.3.0

package/dist/src/common/models/NeonFilterListItem.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Model describing a filter list item.
+ */
+export interface NeonFilterListItem {
+    key: string;
+    label: string;
+    count: number;
+    disabled?: boolean;
+}

package/dist/src/common/models/NeonGridModel.d.ts

@@ -0,0 +1,19 @@
+import type { NeonResponsive } from '../enums/NeonResponsive';
+export declare class NeonGridModel {
+    /**
+     * The breakpoint defining when the provided grid configuration applies.
+     */
+    breakpoint: NeonResponsive;
+    /**
+     * A two dimensional grid of ids defining the layout of the NeonGridAreas with a NeonGrid component's default slot.
+     * E.g.
+     * [
+     *   ['area1', 'area1', 'area2'],
+     *   ['area3', 'area4', 'area2'],
+     * ]
+     *
+     * defines a grid with two rows and 3 columns where id=area1 fills the first two columns on the first row, area2 fills
+     * the last column (both rows) and areas 3 & 4 fill the first two columns on the second row.
+     */
+    grid: string[][];
+}

package/dist/src/common/models/NeonListItem.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Model describing a list item.
+ */
+export interface NeonListItem {
+    key: string;
+    label: string;
+}

package/dist/src/common/models/NeonMenuItem.d.ts

@@ -0,0 +1,7 @@
+export interface NeonMenuItem {
+    key: string;
+    label: string;
+    href?: string;
+    icon?: string;
+    disabled?: boolean;
+}

package/dist/src/common/models/NeonMenuModel.d.ts

@@ -0,0 +1,4 @@
+import type { NeonMenuItem } from './NeonMenuItem';
+export interface NeonMenuModel extends NeonMenuItem {
+    children?: NeonMenuItem[];
+}

package/dist/src/common/models/NeonNumberFormatOptions.d.ts

@@ -0,0 +1,6 @@
+export declare class NeonNumberFormatOptions {
+    decimals?: number;
+    format?: string;
+    percentage?: boolean;
+    minimumFractionDigits?: number;
+}

package/dist/src/common/models/NeonSearchOption.d.ts

@@ -0,0 +1,11 @@
+import type { NeonFunctionalColor } from '../enums/NeonFunctionalColor';
+/**
+ * Model describing a search option.
+ */
+export interface NeonSearchOption {
+    key: string;
+    label: string;
+    chipColor?: NeonFunctionalColor;
+    icon?: string;
+    separatorBefore?: boolean;
+}

package/dist/src/common/models/NeonSelectGroup.d.ts

@@ -0,0 +1,8 @@
+import type { NeonSelectOption } from './NeonSelectOption';
+/**
+ * Model describing a select opt-group and it's options.
+ */
+export interface NeonSelectGroup {
+    group: string;
+    options: NeonSelectOption[];
+}

package/dist/src/common/models/NeonSelectOption.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Model describing a select option.
+ */
+export interface NeonSelectOption {
+    key: string;
+    label: string;
+    icon?: string;
+    separatorBefore?: boolean;
+    disabled?: boolean;
+}

package/dist/src/common/models/NeonTabModel.d.ts

@@ -0,0 +1,5 @@
+export interface NeonTabModel {
+    label: string;
+    key: string;
+    icon?: string;
+}

package/dist/src/common/models/NeonToastMessage.d.ts

@@ -0,0 +1,23 @@
+import type { NeonVerticalPosition } from '../enums/NeonVerticalPosition';
+/**
+ * A 'Toast' style alert message. These are much simpler than normal alerts.
+ */
+export interface NeonToastMessage {
+    /**
+     *  Toast title.
+     */
+    title: string;
+    /**
+     * Placement of the message, either centered at the top or at the bottom. Default is top.
+     */
+    placement?: NeonVerticalPosition;
+    /**
+     * Duration to display the message (default = 2500ms). Set to 0 for the message to never expire (make sure it's
+     * dismissible).
+     */
+    duration?: number;
+    /**
+     * Whether the message can be dismissed by a user click. Default is true.
+     */
+    dismissible?: boolean;
+}

package/dist/src/common/models/NeonToggleModel.d.ts

@@ -0,0 +1,6 @@
+export interface NeonToggleModel {
+    key: string;
+    label?: string;
+    icon?: string;
+    disabled?: boolean;
+}

package/dist/src/common/models/NeonTreeMenuLinkModel.d.ts

@@ -0,0 +1,6 @@
+export interface NeonTreeMenuLinkModel {
+    label: string;
+    key: string;
+    href?: string;
+    anchors?: string[];
+}

package/dist/src/common/models/NeonTreeMenuSectionModel.d.ts

@@ -0,0 +1,8 @@
+import type { NeonTreeMenuLinkModel } from './NeonTreeMenuLinkModel';
+export interface NeonTreeMenuSectionModel {
+    label: string;
+    key: string;
+    children?: NeonTreeMenuLinkModel[];
+    expanded?: boolean;
+    disabled?: boolean;
+}

package/dist/src/common/utils/NeonAlertService.d.ts

@@ -0,0 +1,29 @@
+import type { NeonAlertMessage } from '../models/NeonAlertMessage';
+import { NeonAlertLevel } from '../enums/NeonAlertLevel';
+/**
+ * NeonAlertService is a service for sending alerts to the <strong>NeonAlert</strong> component for display to the user.
+ */
+export declare class NeonAlertService {
+    /**
+     * Send an info message
+     * @param alert {NeonAlertMessage}
+     */
+    static info(alert: NeonAlertMessage): void;
+    /**
+     * Send a success message
+     * @param alert {NeonAlertMessage}
+     */
+    static success(alert: NeonAlertMessage): void;
+    /**
+     * Send a warning message
+     * @param alert {NeonAlertMessage}
+     */
+    static warn(alert: NeonAlertMessage): void;
+    /**
+     * Send an error message
+     * @param alert {NeonAlertMessage}
+     */
+    static error(alert: NeonAlertMessage): void;
+    static generateEventKey(eventType: NeonAlertLevel): string;
+    private static emit;
+}

package/dist/src/common/utils/NeonClipboardService.d.ts

@@ -0,0 +1,6 @@
+export declare class NeonClipboardSupport {
+    supportClipboard: boolean;
+    constructor();
+    copyTo(value: string): Promise<void>;
+}
+export declare const NeonClipboardService: NeonClipboardSupport;

package/dist/src/common/utils/NeonClosableUtils.d.ts

@@ -0,0 +1,11 @@
+export declare class NeonClosableUtils {
+    private readonly target;
+    private readonly closeCallback;
+    private _open;
+    constructor(target: HTMLElement, closeCallback: () => void);
+    open(): void;
+    destroy(): void;
+    escapeKeyListener(event: KeyboardEvent): void;
+    close(): void;
+    private handleOutsideClick;
+}

package/dist/src/common/utils/NeonColorUtils.d.ts

@@ -0,0 +1,43 @@
+import type { NeonContrastAccessibility } from '@/common/models/NeonContrastAccessibility';
+/**
+ * Utility class with helpers for calculating relative contrast & determining accessibility.
+ */
+export declare class NeonColorUtils {
+    private static red;
+    private static green;
+    private static blue;
+    private static labXn;
+    private static labYn;
+    private static labZn;
+    private static labT0;
+    private static labT1;
+    private static labT2;
+    private static labT3;
+    private static degreesToRadians;
+    private static radiansToDegrees;
+    private static gamma;
+    static luminance([r, g, b]: Array<number>): number;
+    static toRgb(hexString: string): Array<number>;
+    static rgbToXyz(rgb: Array<number>): Array<number>;
+    static rgbToLab(rgb: Array<number>): Array<number>;
+    static rgbToHcl(rgb: Array<number>): Array<number>;
+    static isAccessible(rgb1: string, rgb2: string): NeonContrastAccessibility;
+    static contrast(rgb1: Array<number>, rgb2: Array<number>): number;
+    static rgbToHex(rgb: Array<number>): string;
+    static generatePalette(referenceColor: string, darkTextHex: string, lightTextHex: string): Record<string, string>;
+    private static generateChromaCurve;
+    private static generateLuminanceCurve;
+    private static xyzToLab;
+    private static rgbValueToXyz;
+    private static labToHcl;
+    private static luminanceByChannel;
+    private static relativeLuminance;
+    private static contrastRatio;
+    private static labToXyz;
+    private static xyzToRgb;
+    private static labToRgb;
+    private static hclToLab;
+    private static hclToRgb;
+    private static lightReferenceColor;
+    private static darkReferenceColor;
+}

package/dist/src/common/utils/NeonDateUtils.d.ts

@@ -0,0 +1,16 @@
+import type { NeonCalendarConfig } from '@/common/models/NeonCalendarConfig';
+import type { NeonDate } from '@/common/models/NeonDate';
+export declare class NeonDateUtils {
+    /**
+     * Convert an ISO 8601 formatted string to a locale formatted date with a three letter month, a 2 digit day and a locale formatted time.
+     * @param date The date/time as an <a href="https://en.wikipedia.org/wiki/ISO_8601">ISO 8601</a> string.
+     * @param locale The locale for which to convert the date for display purposes, defaults to browser locale.
+     * @param strict Do not add time component to localise the date.
+     */
+    static stringToNeonDate(date: string, locale?: string, strict?: boolean): NeonDate;
+    static dateToIso(date: Date, time?: boolean): string;
+    static dmyToIso(day: number, month: number, year: number): string;
+    static dowNames(locale?: string): Array<string>;
+    static monthNames(locale?: string): Array<string>;
+    static toCalendarConfiguration(selectedDate?: string, currentPageMonth?: number, currentPageYear?: number, currentPageDecadeStart?: number, locale?: string): NeonCalendarConfig;
+}

package/dist/src/common/utils/NeonDebounceUtils.d.ts

@@ -0,0 +1,5 @@
+export declare class NeonDebounceUtils {
+    private static debounceTimeout;
+    static setGlobalDebounceTimeout(debounceTimeout: number): void;
+    static debounce(fn: (...args: any[]) => void, timeout?: number): (...args: any[]) => void;
+}

package/dist/src/common/utils/NeonDropdownPlacementUtils.d.ts

@@ -0,0 +1,6 @@
+import type { NeonDropdownPlacement } from '../enums/NeonDropdownPlacement';
+export declare class NeonDropdownPlacementUtils {
+    static calculatePlacement(triggerElement: HTMLElement, contentElement: HTMLElement, placement: NeonDropdownPlacement, placementContainer?: HTMLElement): NeonDropdownPlacement;
+    private static findPlacement;
+    private static validPlacement;
+}

package/dist/src/common/utils/NeonEventBus.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Event bus used internally for component to component communication. All Neon messages are namespaced with the
+ * messagePrefix below. Feel free to also use it in your applications, just use your own namespace so as not to clash
+ * with Neon's messages.
+ */
+export declare class NeonEventBus {
+    static messagePrefix: string;
+    private static listeners;
+    /**
+     * Listen to event bus events
+     * @param event {string}
+     * @param callback {(...args: any[]) => void}
+     */
+    static on(event: string, callback: (...args: any[]) => void): void;
+    /**
+     * Stop listening to event bus events
+     * @param event {string}
+     * @param callback {(...args: any[]) => void}
+     */
+    static off(event: string, callback: (...args: any[]) => void): void;
+    /**
+     * Emit event bus events
+     * @param event {string}
+     * @param args {any[]}
+     */
+    static emit(event: string, ...args: any[]): void;
+}

package/dist/src/common/utils/NeonIconRegistry.d.ts

@@ -0,0 +1,8 @@
+export declare class NeonIconRegistry {
+    private static icons;
+    static addIcon(name: string, svg: string, overwrite?: boolean): boolean;
+    static removeIcon(name: string): void;
+    static getIcon(name: string): string;
+    static list(): string[];
+    static clear(): void;
+}

package/dist/src/common/utils/NeonModeUtils.d.ts

@@ -0,0 +1,15 @@
+import { NeonMode } from '../enums/NeonMode';
+export declare class NeonModeUtils {
+    private static callbacks;
+    private static defaultMode;
+    private static mode;
+    static getMode(): NeonMode | null;
+    static init(defaultMode?: NeonMode): void;
+    static addListener(key: string, callback: (value: NeonMode) => void): void;
+    static removeListener(key: string): void;
+    private static onDarkChange;
+    private static onLightChange;
+    private static onNoPreferenceChange;
+    private static onChange;
+    private static handleChange;
+}

package/dist/src/common/utils/NeonNumberUtils.d.ts

@@ -0,0 +1,10 @@
+import type { NeonNumberFormatOptions } from '../models/NeonNumberFormatOptions';
+export declare class NeonNumberUtils {
+    static parseExample: string;
+    static decimalSeparator: string;
+    static cleanPattern: RegExp;
+    static PercentageFormat: string;
+    static ValuePlaceholder: string;
+    static formatNumber(value: number, options?: NeonNumberFormatOptions, locale?: string | null): string;
+    static parseNumber(value: string): number;
+}

package/dist/src/common/utils/NeonPlacementUtils.d.ts

@@ -0,0 +1,8 @@
+import type { NeonAvailableSpace } from '../models/NeonAvailableSpace';
+export declare class NeonPlacementUtils {
+    static calculateAvailableSpace(triggerElement: HTMLElement, maxWidth: number, maxHeight: number, placementContainer?: HTMLElement): NeonAvailableSpace;
+    static calculateBounds(placementContainer?: HTMLElement): {
+        maxWidth: number;
+        maxHeight: number;
+    };
+}

package/dist/src/common/utils/NeonResponsiveUtils.d.ts

@@ -0,0 +1,4 @@
+import { NeonResponsive } from '../enums/NeonResponsive';
+export declare class NeonResponsiveUtils {
+    static readonly breakpoints: Record<NeonResponsive, string>;
+}

package/dist/src/common/utils/NeonScrollUtils.d.ts

@@ -0,0 +1,3 @@
+export declare class NeonScrollUtils {
+    static scrollIntoView(element: HTMLElement): void;
+}

package/dist/src/common/utils/NeonToastService.d.ts

@@ -0,0 +1,29 @@
+import type { NeonToastMessage } from '../models/NeonToastMessage';
+import { NeonAlertLevel } from '../enums/NeonAlertLevel';
+/**
+ * NeonToastService is a service for sending toast alerts to the <strong>NeonAlert</strong> component for display to the user.
+ */
+export declare class NeonToastService {
+    /**
+     * Send an info message
+     * @param alert {NeonToastMessage}
+     */
+    static info(alert: NeonToastMessage): void;
+    /**
+     * Send a success message
+     * @param alert {NeonToastMessage}
+     */
+    static success(alert: NeonToastMessage): void;
+    /**
+     * Send a warning message
+     * @param alert {NeonToastMessage}
+     */
+    static warn(alert: NeonToastMessage): void;
+    /**
+     * Send an error message
+     * @param alert {NeonToastMessage}
+     */
+    static error(alert: NeonToastMessage): void;
+    static generateEventKey(eventType: NeonAlertLevel): string;
+    private static emit;
+}

package/dist/src/common/utils/NeonTooltipPlacementUtils.d.ts

@@ -0,0 +1,7 @@
+import { NeonPlacement } from '../enums/NeonPlacement';
+export declare class NeonTooltipPlacementUtils {
+    static calculatePlacement(triggerElement: HTMLElement, contentElement: HTMLElement, placement: NeonPlacement, placementContainer?: HTMLElement): NeonPlacement;
+    private static calculatePlacementOrder;
+    private static findPlacement;
+    private static validPlacement;
+}

package/dist/src/common/utils/RegisterIcons.d.ts

@@ -0,0 +1,3 @@
+export declare class RegisterIcons {
+    static register(): void;
+}

package/dist/src/components/feedback/alert/NeonAlert.d.ts

@@ -0,0 +1,129 @@
+import { NeonAlertLevel } from '@/common/enums/NeonAlertLevel';
+import { NeonAlertPlacement } from '@/common/enums/NeonAlertPlacement';
+import { NeonVerticalPosition } from '@/common/enums/NeonVerticalPosition';
+/**
+ * NeonAlert is a component for presenting temporary notifications to the user. Place the component once inside your app
+ * and use <strong>NeonAlertService</strong> to send events to the component.
+ */
+declare const _default: import("vue").DefineComponent<{
+    /**
+     * Whether alert messages are dismissible by clicking on them. This can also be set per alert message.
+     */
+    dismissible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Duration to display messages before removing them. This can also be set per alert message. Set the duration to 0 to
+     * disable the duration timer, NOTE: this requires the user to dismiss the alert by clicking on it.
+     */
+    duration: {
+        type: NumberConstructor;
+        default: number;
+    };
+}, {
+    topLeft: import("vue").Ref<{
+        id: number;
+        level: NeonAlertLevel;
+        title?: string | undefined;
+        message?: string | undefined;
+        placement?: NeonAlertPlacement | undefined;
+        duration?: number | undefined;
+        dismissible?: boolean | undefined;
+        primaryAction?: {
+            label: string;
+            callback: () => void;
+        } | undefined;
+        secondaryAction?: {
+            label: string;
+            callback: () => void;
+        } | undefined;
+    }[]>;
+    topRight: import("vue").Ref<{
+        id: number;
+        level: NeonAlertLevel;
+        title?: string | undefined;
+        message?: string | undefined;
+        placement?: NeonAlertPlacement | undefined;
+        duration?: number | undefined;
+        dismissible?: boolean | undefined;
+        primaryAction?: {
+            label: string;
+            callback: () => void;
+        } | undefined;
+        secondaryAction?: {
+            label: string;
+            callback: () => void;
+        } | undefined;
+    }[]>;
+    bottomLeft: import("vue").Ref<{
+        id: number;
+        level: NeonAlertLevel;
+        title?: string | undefined;
+        message?: string | undefined;
+        placement?: NeonAlertPlacement | undefined;
+        duration?: number | undefined;
+        dismissible?: boolean | undefined;
+        primaryAction?: {
+            label: string;
+            callback: () => void;
+        } | undefined;
+        secondaryAction?: {
+            label: string;
+            callback: () => void;
+        } | undefined;
+    }[]>;
+    bottomRight: import("vue").Ref<{
+        id: number;
+        level: NeonAlertLevel;
+        title?: string | undefined;
+        message?: string | undefined;
+        placement?: NeonAlertPlacement | undefined;
+        duration?: number | undefined;
+        dismissible?: boolean | undefined;
+        primaryAction?: {
+            label: string;
+            callback: () => void;
+        } | undefined;
+        secondaryAction?: {
+            label: string;
+            callback: () => void;
+        } | undefined;
+    }[]>;
+    top: import("vue").Ref<{
+        id: number;
+        level: NeonAlertLevel;
+        title: string;
+        placement?: NeonVerticalPosition | undefined;
+        duration?: number | undefined;
+        dismissible?: boolean | undefined;
+    }[]>;
+    bottom: import("vue").Ref<{
+        id: number;
+        level: NeonAlertLevel;
+        title: string;
+        placement?: NeonVerticalPosition | undefined;
+        duration?: number | undefined;
+        dismissible?: boolean | undefined;
+    }[]>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    /**
+     * Whether alert messages are dismissible by clicking on them. This can also be set per alert message.
+     */
+    dismissible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Duration to display messages before removing them. This can also be set per alert message. Set the duration to 0 to
+     * disable the duration timer, NOTE: this requires the user to dismiss the alert by clicking on it.
+     */
+    duration: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>>, {
+    dismissible: boolean;
+    duration: number;
+}>;
+export default _default;

package/dist/src/components/feedback/alert/NeonAlert.vue.d.ts

@@ -0,0 +1,2 @@
+export * from './NeonAlert.js';
+export { default } from './NeonAlert.js';

package/dist/src/components/feedback/alert/NeonAlertModel.d.ts

@@ -0,0 +1,6 @@
+import type { NeonAlertMessage } from '@/common/models/NeonAlertMessage';
+import type { NeonAlertLevel } from '@/common/enums/NeonAlertLevel';
+export interface NeonAlertModel extends NeonAlertMessage {
+    id: number;
+    level: NeonAlertLevel;
+}

package/dist/src/components/feedback/alert/NeonToastModel.d.ts

@@ -0,0 +1,6 @@
+import type { NeonAlertLevel } from '@/common/enums/NeonAlertLevel';
+import type { NeonToastMessage } from '@/common/models/NeonToastMessage';
+export interface NeonToastModel extends NeonToastMessage {
+    id: number;
+    level: NeonAlertLevel;
+}

package/dist/src/components/feedback/alert/container/NeonAlertContainer.d.ts

@@ -0,0 +1,29 @@
+import { NeonAlertLevel } from '@/common/enums/NeonAlertLevel';
+import type { NeonAlertPlacement } from '@/common/enums/NeonAlertPlacement';
+import type { NeonAlertModel } from '../NeonAlertModel';
+/**
+ * This is an internal component for rendering alerts.
+ */
+declare const _default: import("vue").DefineComponent<{
+    modelValue: {
+        type: () => Array<NeonAlertModel>;
+        required: true;
+    };
+    placement: {
+        type: () => NeonAlertPlacement;
+        required: true;
+    };
+}, {
+    closeMessage: (id: number) => void;
+    icon: (level: NeonAlertLevel) => "info-circle" | "check-circle" | "exclamation-circle" | "times-circle";
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: () => Array<NeonAlertModel>;
+        required: true;
+    };
+    placement: {
+        type: () => NeonAlertPlacement;
+        required: true;
+    };
+}>>, {}>;
+export default _default;

package/dist/src/components/feedback/alert/container/NeonAlertContainer.vue.d.ts

@@ -0,0 +1,2 @@
+export * from './NeonAlertContainer.js';
+export { default } from './NeonAlertContainer.js';

package/dist/src/components/feedback/alert/container/NeonToastContainer.d.ts

@@ -0,0 +1,27 @@
+import type { NeonToastModel } from '../NeonToastModel';
+import type { NeonVerticalPosition } from '@/common/enums/NeonVerticalPosition';
+/**
+ * This is an internal component for rendering alerts.
+ */
+declare const _default: import("vue").DefineComponent<{
+    modelValue: {
+        type: () => Array<NeonToastModel>;
+        required: true;
+    };
+    placement: {
+        type: () => NeonVerticalPosition;
+        required: true;
+    };
+}, {
+    closeMessage: (id: number) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: () => Array<NeonToastModel>;
+        required: true;
+    };
+    placement: {
+        type: () => NeonVerticalPosition;
+        required: true;
+    };
+}>>, {}>;
+export default _default;

package/dist/src/components/feedback/alert/container/NeonToastContainer.vue.d.ts

@@ -0,0 +1,2 @@
+export * from './NeonToastContainer.js';
+export { default } from './NeonToastContainer.js';