@six-group/ui-library 0.0.0-insider.012ddb2

package/dist/types/testUtil/delay.d.ts

@@ -0,0 +1 @@
+export declare const delay: (time: number) => Promise<unknown>;

package/dist/types/types.d.ts

@@ -0,0 +1,3 @@
+export * from './components';
+export * from './utils/error-messages';
+export * from './utils/alert';

package/dist/types/utils/alert.d.ts

@@ -0,0 +1,10 @@
+import { AlertType } from '../components/six-alert/six-alert';
+/**
+ * Displays an alert on the toast stack with a specified message and optional configuration.
+ *
+ * @param message - The message to be displayed in the alert.
+ * @param alertType - The type of the alert. Valid values are 'primary', 'info', 'success', 'warning', 'danger'. Default is 'info'.
+ * @param duration - The duration in milliseconds for which the alert is displayed. If not provided, a default duration is set based on the alert type.
+ * @param iconName - The name of the icon to be displayed in the alert. If not provided, a default icon is set based on the alert type.
+ */
+export declare function showAlert(message: string, alertType?: AlertType, duration?: number, iconName?: string): void;

package/dist/types/utils/animation.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Animates a given `element` from the position and dimension of `fromElement` to
+ * its current position and dimension. Can be useful to implement the FLIP animation technique.
+ *
+ * @see {@link https://css-tricks.com/animating-layouts-with-the-flip-technique/} for details on the FLIP technique.
+ *
+ * @param {Element} element - The element to animate.
+ * @param {Element} fromElement - The element representing the initial position and dimensions.
+ * @param {KeyframeAnimationOptions} [options={ duration: 150, easing: 'ease', fill: 'both' }] - Optional animation parameters.
+ *
+ */
+export declare function flipAnimate(element: Element, fromElement: Element, options?: KeyframeAnimationOptions): void;

package/dist/types/utils/date-util.d.ts

@@ -0,0 +1,210 @@
+import { SixDateFormats } from '../components/six-datepicker/six-date-formats';
+import { CalendarCell } from '../components/six-datepicker/six-datepicker';
+export type DateLocale = typeof i18nDate.en;
+export declare const i18nDate: {
+    en: {
+        months: string[];
+        monthsShort: string[];
+        monthsShortGrouped: string[][];
+        weekdays: string[];
+        weekdaysShort: string[];
+        weekdaysMin: string[];
+    };
+    de: {
+        months: string[];
+        monthsShort: string[];
+        monthsShortGrouped: string[][];
+        weekdays: string[];
+        weekdaysShort: string[];
+        weekdaysMin: string[];
+    };
+    fr: {
+        months: string[];
+        monthsShort: string[];
+        monthsShortGrouped: string[][];
+        weekdays: string[];
+        weekdaysShort: string[];
+        weekdaysMin: string[];
+    };
+    it: {
+        months: string[];
+        monthsShort: string[];
+        monthsShortGrouped: string[][];
+        weekdays: string[];
+        weekdaysShort: string[];
+        weekdaysMin: string[];
+    };
+    es: {
+        months: string[];
+        monthsShort: string[];
+        monthsShortGrouped: string[][];
+        weekdays: string[];
+        weekdaysShort: string[];
+        weekdaysMin: string[];
+    };
+};
+/**
+ * Returns a JS Date instance of the exact moment
+ *
+ * ```typescript
+ * const date = now()
+ * // Wed Mar 10 2021 20:30:32 GMT+0100 (Central European Standard Time)
+ * ```
+ */
+export declare const now: () => Date;
+export declare const removeTime: (date: Date) => Date;
+export declare const pad: (value: number) => string;
+/**
+ * Returns `true` if the given date is valid
+ */
+export declare const isValidDate: (value: unknown) => boolean;
+/**
+ * Returns the year number of the given date
+ *
+ * ```typescript
+ * year(new Date(2020, 0, 1)) // 2020
+ * ```
+ */
+export declare const year: (date: Date | undefined) => number;
+/**
+ * Returns the month number of the given date
+ *
+ * ```typescript
+ * month(new Date(2020, 0, 1)) // 0
+ * ```
+ */
+export declare const month: (date: Date | undefined) => number;
+/**
+ * Returns the day number of the given date
+ *
+ * ```typescript
+ * day(new Date(2020, 0, 1)) // 1
+ * ```
+ */
+export declare const day: (date: Date | undefined) => number;
+/**
+ * Returns the hours of the given date
+ */
+export declare const hours: (date: Date | undefined) => number;
+/**
+ * Returns the minutes of the given date
+ */
+export declare const minutes: (date: Date | undefined) => number;
+/**
+ * Returns the seconds of the given date
+ */
+export declare const seconds: (date: Date | undefined) => number;
+/**
+ * Returns the first day of the week of the given date.
+ */
+export declare const getFirstDayOfTheWeek: (date: Date) => Date;
+/**
+ * Returns `true` when the year of the dates are the same
+ */
+export declare const isSameYear: (a: Date | undefined, b: Date | undefined) => boolean;
+/**
+ * Returns `true` when the month of the dates are the same
+ */
+export declare const isSameMonth: (a: Date | undefined, b: Date | undefined) => boolean;
+/**
+ * Returns `true` when the day of the dates are the same
+ */
+export declare const isSameDay: (a: Date | undefined, b: Date | undefined) => boolean;
+/**
+ * Returns `true` when the week of the dates are the same
+ */
+export declare const isSameWeek: (a: Date, b: Date) => boolean;
+/**
+ * Returns the ISO string `yyyy-mm-dd` of the given date
+ *
+ * ```typescript
+ * isoString(new Date(2020, 0, 13)) // '2020-01-13'
+ * ```
+ */
+export declare const isoString: (date: Date | undefined) => string;
+/**
+ * Returns the ISO string `yyyy-mm-dd` of the given parameters year, month and day
+ *
+ * ```typescript
+ * newDateString(2020, 0, 13) // '2020-01-13'
+ * or
+ * newDateString(new Date(2020, 0, 13)) // '2020-01-13'
+ * ```
+ */
+export declare const newDateString: (yearOrDate: Date | number, month?: number, day?: number) => string;
+/**
+ * Returns `true` if the given datestring is valid
+ */
+export declare const isValidDateString: (datestring: string | undefined, format: string) => boolean;
+/**
+ * Returns `true` when the given date is not smaller than the minDate and not bigger than the maxDate.
+ *
+ * ```typescript
+ * isInRange(new Date(2020, 1, 1), new Date(2020, 0, 1), new Date(2020, 2, 1)) // true
+ * ```
+ */
+export declare const isInRange: (date: Date | undefined, minDate: Date | undefined, maxDate: Date | undefined) => boolean;
+/**
+ * Returns `true` when the given date is not smaller than the before date.
+ *
+ * ```typescript
+ * isBefore(new Date(2020, 1, 1), new Date(2020, 3, 1)) // true
+ * ```
+ */
+export declare const isBefore: (date: any, beforeDate: Date | string | undefined) => boolean;
+/**
+ * Returns `true` when the given date is not smaller than the before date.
+ *
+ * ```typescript
+ * isAfter(new Date(2020, 5, 1), new Date(2020, 3, 1)) // true
+ * ```
+ */
+export declare const isAfter: (date: any, afterDate: Date | string | undefined) => boolean;
+/**
+ * Increases the year of a date and retunrs the result
+ *
+ * ```typescript
+ * increaseYear(new Date(2020, 0, 1), 1) // 2021
+ * ```
+ */
+export declare const increaseYear: (date: Date, years: number) => number;
+/**
+ * Decreases the year of a date and retunrs the result
+ *
+ * ```typescript
+ * decreaseYear(new Date(2020, 0, 1), 1) // 2019
+ * ```
+ */
+export declare const decreaseYear: (date: Date, years: number) => number;
+export declare const formatDate: (date: Date | undefined | null, format: string) => string;
+export declare const parseDate: (value: any, format: string, locale: string) => Date;
+export declare const toDate: (dirtyDateString: string | undefined, format: string) => Date | undefined;
+export interface PointerDate {
+    year: number;
+    month: number;
+    day: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+}
+export interface CalendarGridArgs {
+    firstDateOfBox: Date;
+    minDate?: Date;
+    maxDate?: Date;
+    dateFormat: SixDateFormats;
+    pointerDate: {
+        month: number;
+        year: number;
+        day: number;
+    };
+    allowedDates: (date: Date) => boolean;
+    locale: 'en' | 'de' | 'fr' | 'it' | 'es';
+    selectedDate?: Date;
+}
+export declare const createCalendarGrid: (calendarGridArguments: CalendarGridArgs) => CalendarCell[][];
+/**
+ * Returns a range of numbers around the given number grouped into buckets of 5.
+ * @param number the given number around which you want to get the other numbers
+ * @param range range of numbers to include in the result
+ */
+export declare function rangeAround(number: number, range: number): number[][];

package/dist/types/utils/error-messages.d.ts

@@ -0,0 +1,44 @@
+export declare const languages: readonly ["de", "fr", "it", "en", "es"];
+export type Language = (typeof languages)[number];
+export type ValidationError = {
+    key: 'required';
+} | {
+    key: 'requiredtrue';
+} | {
+    key: 'email';
+    requiredPattern: string;
+} | {
+    key: 'minlength';
+    requiredLength: number;
+} | {
+    key: 'maxlength';
+    requiredLength: number;
+} | {
+    key: 'pattern';
+    requiredPattern: string;
+} | {
+    key: 'min';
+    min: number;
+} | {
+    key: 'max';
+    max: number;
+} | {
+    key: 'mindate';
+    mindate: Date;
+    actual: Date;
+} | {
+    key: 'maxdate';
+    maxdate: Date;
+    actual: Date;
+} | {
+    key: 'invaliddate';
+    actual: Date;
+} | {
+    key: 'custom';
+    text: string;
+};
+/**
+ * Returns an error message for the given language and error.
+ */
+export declare function getErrorMessage(language: Language, error: ValidationError): string | undefined;
+export declare function getLanguage(): Language;

package/dist/types/utils/event-listeners.d.ts

@@ -0,0 +1,16 @@
+interface EventListener {
+    el: GlobalEventHandlers;
+    name: string;
+    listener: EventListenerOrEventListenerObject;
+    identifier?: string | null;
+}
+export declare class EventListeners {
+    eventListeners: EventListener[];
+    add: <T extends GlobalEventHandlers>(el: T, name: string, listener: EventListenerOrEventListenerObject, identifier?: string | null | undefined) => void;
+    remove: <T extends GlobalEventHandlers>(el: T, name: string, listener: EventListenerOrEventListenerObject) => void;
+    removeByIdentifier: (identifier: string) => void;
+    private getFilteredEventListeners;
+    removeAll: () => void;
+    forward(from: string, to: 'input' | 'change' | 'blur' | 'focus', host: HTMLElement): void;
+}
+export {};

package/dist/types/utils/execution-control.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter } from '../stencil-public-runtime';
+export declare const DEFAULT_DEBOUNCE_INSANELY_FAST = 35;
+export declare const DEFAULT_DEBOUNCE_FAST = 300;
+/**
+ * Debounce function to implement a timeframe to wait for no new changes before executing a callback
+
+ *  example usages:
+ *    debounce(() => saveInput());
+ *    debounce(() => saveInput(), 750);
+ *    this.searchInput.addEventListener('six-input-input', debounce((event) => this.searchInputChange(event)));
+ *
+ *  regarding default timeout check https://lawsofux.com/doherty-threshold/
+ *
+ * @param callback
+ * @param timeout
+ */
+export declare const debounce: <T>(callback: (x: T) => void, timeout?: number) => (args: T) => void;
+/**
+ * Debounce an event
+ *
+ * @param event
+ * @param timeout
+ */
+export declare const debounceEvent: (event: EventEmitter, timeout: number) => EventEmitter;

package/dist/types/utils/focus-visible.d.ts

@@ -0,0 +1,6 @@
+export declare function observe(el: HTMLElement): void;
+export declare function unobserve(el: HTMLElement): void;
+export declare const focusVisible: {
+    observe: typeof observe;
+    unobserve: typeof unobserve;
+};

package/dist/types/utils/form.d.ts

@@ -0,0 +1 @@
+export declare function submitForm(element: HTMLElement): void;

package/dist/types/utils/modal.d.ts

@@ -0,0 +1,13 @@
+interface ModalOptions {
+    onFocusOut?: (event: Event) => void;
+}
+export default class Modal {
+    element: HTMLElement;
+    options?: ModalOptions;
+    constructor(element: HTMLElement, options?: ModalOptions);
+    activate(): void;
+    deactivate(): void;
+    isActive(): boolean;
+    handleFocusIn(event: Event): void;
+}
+export {};

package/dist/types/utils/offset.d.ts

@@ -0,0 +1,4 @@
+export declare function getOffset(element: HTMLElement, parent: HTMLElement): {
+    top: number;
+    left: number;
+};

package/dist/types/utils/popover.d.ts

@@ -0,0 +1,27 @@
+import { Instance } from '@popperjs/core';
+export default class Popover {
+    anchor: HTMLElement;
+    isVisible: boolean;
+    popover: HTMLElement;
+    popper?: Instance;
+    options: PopoverOptions;
+    constructor(anchor: HTMLElement, popover: HTMLElement, options?: PopoverOptions);
+    private handleTransitionEnd;
+    destroy(): void;
+    show(): void;
+    reposition(): void;
+    hide(): void;
+    setOptions(options: PopoverOptions): void;
+}
+interface PopoverOptions {
+    distance?: number;
+    placement?: 'auto' | 'auto-start' | 'auto-end' | 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'right' | 'right-start' | 'right-end' | 'left' | 'left-start' | 'left-end';
+    skidding?: number;
+    strategy?: 'absolute' | 'fixed';
+    transitionElement?: HTMLElement;
+    visibleClass?: string;
+    onAfterShow?: () => void;
+    onAfterHide?: () => void;
+    onTransitionEnd?: (event: TransitionEvent) => void;
+}
+export {};

package/dist/types/utils/popup.d.ts

@@ -0,0 +1,9 @@
+/**
+ * If the popup is hoisted we popup is hoisted its position will change to fix to not be clipped of by a containing container.
+ * To render the popup correctly we render it normally, and then assign this screenposition to the fixed popup
+ */
+export declare function adjustPopupForHoisting(hoist: boolean, popup: HTMLElement | undefined, inputElement: HTMLElement | undefined, wrapper: HTMLElement | undefined, minPopupHeight: number, dropdownDirectionChanged: (isUp: boolean) => void): void;
+export declare function adjustPopupForSmallScreens(popup?: HTMLElement): void;
+export declare function calcIsDropDownContentUp(inputElement: HTMLElement, wrapper: HTMLElement, minPopupHeight: number): boolean;
+export declare function setPopupAsFixPosition(popup: HTMLElement): DOMRect;
+export declare function movePopup(hoist: boolean, open: boolean, popup: HTMLElement | undefined, inputElement: HTMLElement | undefined, wrapper: HTMLElement | undefined, minPopupHeight: number): void;

package/dist/types/utils/scroll.d.ts

@@ -0,0 +1,3 @@
+export declare function lockBodyScrolling(lockingEl: HTMLElement): void;
+export declare function unlockBodyScrolling(lockingEl: HTMLElement): void;
+export declare function scrollIntoView(element: HTMLElement, container: HTMLElement, direction?: 'horizontal' | 'vertical' | 'both', behavior?: 'smooth' | 'auto'): void;

package/dist/types/utils/slot.d.ts

@@ -0,0 +1,3 @@
+export declare function getTextContent(slot?: HTMLSlotElement): string;
+export declare function hasSlot(el: HTMLElement, name?: string): boolean;
+export declare function getSlot(element: ParentNode | null | undefined, slotName: string): HTMLElement | null;

package/dist/types/utils/support.d.ts

@@ -0,0 +1 @@
+export declare const isPreventScrollSupported: () => boolean;

package/dist/types/utils/tabbable.d.ts

@@ -0,0 +1,2 @@
+export declare function isTabbable(el: HTMLElement): boolean;
+export declare function getNearestTabbableElement(el: HTMLElement): HTMLElement | undefined;

package/dist/types/utils/time.util.d.ts

@@ -0,0 +1,19 @@
+export type TimePeriod = 'AM' | 'PM';
+export interface Time {
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+    milliseconds?: number;
+    has24Hours?: boolean;
+    period?: TimePeriod;
+}
+export type TimeProperties = keyof Time;
+export type TimeFormatChar = 'HH' | 'hh' | 'mm' | 'ss' | 'ms' | 'aa';
+export type TimeFormat = 'HH:mm:ss' | 'hh:mm:ss:aa' | 'HH:mm:ss:ms' | 'hh:mm:ss:ms:aa' | 'HH:mm' | 'hh:mm:aa' | 'HH' | 'hh:aa' | 'mm' | 'ss' | 'ms';
+export declare const getCurrentTimeIn24Hours: () => Time;
+export declare const getHoursIn12HourFormat: (hours: number) => number;
+export declare const getCurrentTimeIn12Hours: () => Time;
+export declare const getCurrentTime: (has24Hours?: boolean) => Time;
+export declare const isValidTimeString: (timeStr: string, format: TimeFormat) => boolean;
+export declare const parseTimeString: (timeStr: string, format: TimeFormat) => Time;
+export declare const createTimeString: (time: Time | undefined, format: TimeFormat) => string;

package/dist/types/utils/type-check.d.ts

@@ -0,0 +1,3 @@
+export declare const isString: (value: unknown) => value is string;
+export declare const isNil: (value: unknown) => value is null | undefined;
+export declare const isDate: (value: unknown) => value is Date;

package/dist/types/utils/types.d.ts

@@ -0,0 +1,4 @@
+export type EmptyPayload = undefined;
+export interface StyleDeclaration {
+    [key: string]: string | undefined;
+}

package/dist/ui-library/assets/TRADEMARKS.md

@@ -0,0 +1,7 @@
+# Trademarks
+
+This project may contain trademarks or logos for projects, products, or services. Authorized use of SIX Group AG
+trademarks or logos is subject to and must follow
+[SIX Group's Guidlines](https://www.six-group.com/dam/download/media/guidelines/SIX-guidelines-product-referencing.pdf).
+Use of SIX Group trademarks or logos in modified versions of this project must not cause confusion or imply SIX Group sponsorship.
+Any use of third-party trademarks or logos are subject to those third-party's policies.

package/dist/ui-library/assets/commons.js

@@ -0,0 +1,5 @@
+const getRows = () => fetch('../assets/data.json').then((res) => res.json());
+
+const getElements = (e) => Object.entries(e).reduce((e, [r, t]) => ({ ...e, [r]: document.querySelector(t) }), {});
+
+const delay = (ms = 3000) => new Promise((resolve) => setTimeout(resolve, ms));