govuk_publishing_components 58.1.0 → 58.2.0

data/node_modules/choices.js/public/types/src/scripts/interfaces/store.d.ts

@@ -0,0 +1,64 @@
+import { StateChangeSet, State } from './state';
+import { ChoiceFull } from './choice-full';
+import { GroupFull } from './group-full';
+import { ActionTypes } from './action-type';
+export interface AnyAction<A extends ActionTypes = ActionTypes> {
+    type: A;
+}
+export interface StateUpdate<T> {
+    update: boolean;
+    state: T;
+}
+export type Reducer<T> = (state: T, action: AnyAction, context?: unknown) => StateUpdate<T>;
+export type StoreListener = (changes: StateChangeSet) => void;
+export interface Store {
+    dispatch(action: AnyAction): void;
+    subscribe(onChange: StoreListener): void;
+    withTxn(func: () => void): void;
+    reset(): void;
+    get defaultState(): State;
+    /**
+     * Get store object
+     */
+    get state(): State;
+    /**
+     * Get items from store
+     */
+    get items(): ChoiceFull[];
+    /**
+     * Get highlighted items from store
+     */
+    get highlightedActiveItems(): ChoiceFull[];
+    /**
+     * Get choices from store
+     */
+    get choices(): ChoiceFull[];
+    /**
+     * Get active choices from store
+     */
+    get activeChoices(): ChoiceFull[];
+    /**
+     * Get choices that can be searched (excluding placeholders)
+     */
+    get searchableChoices(): ChoiceFull[];
+    /**
+     * Get groups from store
+     */
+    get groups(): GroupFull[];
+    /**
+     * Get active groups from store
+     */
+    get activeGroups(): GroupFull[];
+    /**
+     * Get loading state from store
+     */
+    inTxn(): boolean;
+    /**
+     * Get single choice by it's ID
+     */
+    getChoiceById(id: number): ChoiceFull | undefined;
+    /**
+     * Get group by group id
+     */
+    getGroupById(id: number): GroupFull | undefined;
+}

data/node_modules/choices.js/public/types/src/scripts/interfaces/string-pre-escaped.d.ts

@@ -0,0 +1,3 @@
+export interface StringPreEscaped {
+    readonly trusted: string;
+}

data/node_modules/choices.js/public/types/src/scripts/interfaces/string-untrusted.d.ts

@@ -0,0 +1,4 @@
+export interface StringUntrusted {
+    readonly escaped: string;
+    readonly raw: string;
+}

data/node_modules/choices.js/public/types/src/scripts/interfaces/templates.d.ts

@@ -0,0 +1,29 @@
+import { PassedElementType } from './passed-element-type';
+import { StringPreEscaped } from './string-pre-escaped';
+import { ChoiceFull } from './choice-full';
+import { GroupFull } from './group-full';
+import { Options } from './options';
+import { Types } from './types';
+export type TemplateOptions = Pick<Options, 'classNames' | 'allowHTML' | 'removeItemButtonAlignLeft' | 'removeItemIconText' | 'removeItemLabelText' | 'searchEnabled' | 'labelId'>;
+export declare const NoticeTypes: {
+    readonly noChoices: "no-choices";
+    readonly noResults: "no-results";
+    readonly addChoice: "add-choice";
+    readonly generic: "";
+};
+export type NoticeType = Types.ValueOf<typeof NoticeTypes>;
+export type CallbackOnCreateTemplatesFn = (template: Types.StrToEl, escapeForTemplate: Types.EscapeForTemplateFn, getClassNames: Types.GetClassNamesFn) => Partial<Templates>;
+export interface Templates {
+    containerOuter(options: TemplateOptions, dir: HTMLElement['dir'], isSelectElement: boolean, isSelectOneElement: boolean, searchEnabled: boolean, passedElementType: PassedElementType, labelId: string): HTMLDivElement;
+    containerInner({ classNames: { containerInner } }: TemplateOptions): HTMLDivElement;
+    itemList(options: TemplateOptions, isSelectOneElement: boolean): HTMLDivElement;
+    placeholder(options: TemplateOptions, value: StringPreEscaped | string): HTMLDivElement;
+    item(options: TemplateOptions, choice: ChoiceFull, removeItemButton: boolean): HTMLDivElement;
+    choiceList(options: TemplateOptions, isSelectOneElement: boolean): HTMLDivElement;
+    choiceGroup(options: TemplateOptions, group: GroupFull): HTMLDivElement;
+    choice(options: TemplateOptions, choice: ChoiceFull, selectText: string, groupText?: string): HTMLDivElement;
+    input(options: TemplateOptions, placeholderValue: string | null): HTMLInputElement;
+    dropdown(options: TemplateOptions): HTMLDivElement;
+    notice(options: TemplateOptions, innerText: string, type: NoticeType): HTMLDivElement;
+    option(choice: ChoiceFull): HTMLOptionElement;
+}

data/node_modules/choices.js/public/types/src/scripts/interfaces/types.d.ts

@@ -0,0 +1,18 @@
+import { StringUntrusted } from './string-untrusted';
+import { StringPreEscaped } from './string-pre-escaped';
+export declare namespace Types {
+    type StrToEl = (str: string) => HTMLElement | HTMLInputElement | HTMLOptionElement;
+    type EscapeForTemplateFn = (allowHTML: boolean, s: StringUntrusted | StringPreEscaped | string) => string;
+    type GetClassNamesFn = (s: string | Array<string>) => string;
+    type StringFunction = () => string;
+    type NoticeStringFunction = (value: string, valueRaw: string) => string;
+    type NoticeLimitFunction = (maxItemCount: number) => string;
+    type FilterFunction = (value: string) => boolean;
+    type ValueCompareFunction = (value1: string, value2: string) => boolean;
+    interface RecordToCompare {
+        value?: StringUntrusted | string;
+        label?: StringUntrusted | string;
+    }
+    type ValueOf<T extends object> = T[keyof T];
+    type CustomProperties = Record<string, any> | string;
+}

data/node_modules/choices.js/public/types/src/scripts/lib/choice-input.d.ts

@@ -0,0 +1,9 @@
+import { InputChoice } from '../interfaces/input-choice';
+import { InputGroup } from '../interfaces/input-group';
+import { GroupFull } from '../interfaces/group-full';
+import { ChoiceFull } from '../interfaces/choice-full';
+type MappedInputTypeToChoiceType<T extends string | InputChoice | InputGroup> = T extends InputGroup ? GroupFull : ChoiceFull;
+export declare const coerceBool: (arg: unknown, defaultValue?: boolean) => boolean;
+export declare const stringToHtmlClass: (input: string | string[] | undefined) => string[] | undefined;
+export declare const mapInputToChoice: <T extends string | InputChoice | InputGroup>(value: T, allowGroup: boolean, allowRawString?: boolean) => MappedInputTypeToChoiceType<T>;
+export {};

data/node_modules/choices.js/public/types/src/scripts/lib/html-guard-statements.d.ts

@@ -0,0 +1,4 @@
+export declare const isHtmlInputElement: (e: Element) => e is HTMLInputElement;
+export declare const isHtmlSelectElement: (e: Element) => e is HTMLSelectElement;
+export declare const isHtmlOption: (e: Element) => e is HTMLOptionElement;
+export declare const isHtmlOptgroup: (e: Element) => e is HTMLOptGroupElement;

data/node_modules/choices.js/public/types/src/scripts/lib/utils.d.ts

@@ -0,0 +1,31 @@
+import { EventTypes } from '../interfaces/event-type';
+import { StringUntrusted } from '../interfaces/string-untrusted';
+import { StringPreEscaped } from '../interfaces/string-pre-escaped';
+import { ChoiceFull } from '../interfaces/choice-full';
+import { Types } from '../interfaces/types';
+export declare const generateId: (element: HTMLInputElement | HTMLSelectElement, prefix: string) => string;
+export declare const getAdjacentEl: (startEl: HTMLElement, selector: string, direction?: number) => HTMLElement | null;
+export declare const isScrolledIntoView: (element: HTMLElement, parent: HTMLElement, direction?: number) => boolean;
+export declare const sanitise: <T>(value: T | StringUntrusted | StringPreEscaped | string) => T | string;
+export declare const strToEl: (str: string) => Element;
+export declare const resolveNoticeFunction: (fn: Types.NoticeStringFunction | string, value: string) => string;
+export declare const resolveStringFunction: (fn: Types.StringFunction | string) => string;
+export declare const unwrapStringForRaw: (s?: StringUntrusted | StringPreEscaped | string) => string;
+export declare const unwrapStringForEscaped: (s?: StringUntrusted | StringPreEscaped | string) => string;
+export declare const escapeForTemplate: (allowHTML: boolean, s: StringUntrusted | StringPreEscaped | string) => string;
+export declare const setElementHtml: (el: HTMLElement, allowHtml: boolean, html: StringUntrusted | StringPreEscaped | string) => void;
+export declare const sortByAlpha: ({ value, label }: Types.RecordToCompare, { value: value2, label: label2 }: Types.RecordToCompare) => number;
+export declare const sortByScore: (a: Pick<ChoiceFull, "score">, b: Pick<ChoiceFull, "score">) => number;
+export declare const sortByRank: (a: Pick<ChoiceFull, "rank">, b: Pick<ChoiceFull, "rank">) => number;
+export declare const dispatchEvent: (element: HTMLElement, type: EventTypes, customArgs?: object | null) => boolean;
+export declare const cloneObject: <T>(obj: T) => T;
+/**
+ * Returns an array of keys present on the first but missing on the second object
+ */
+export declare const diff: (a: Record<string, any>, b: Record<string, any>) => string[];
+export declare const getClassNames: (ClassNames: Array<string> | string) => Array<string>;
+export declare const getClassNamesSelector: (option: string | Array<string> | null) => string;
+export declare const addClassesToElement: (element: HTMLElement, className: Array<string> | string) => void;
+export declare const removeClassesFromElement: (element: HTMLElement, className: Array<string> | string) => void;
+export declare const parseCustomProperties: (customProperties?: string) => object | string;
+export declare const updateClassList: (item: ChoiceFull, add: string | string[], remove: string | string[]) => void;

data/node_modules/choices.js/public/types/src/scripts/reducers/choices.d.ts

@@ -0,0 +1,8 @@
+import { Options, State } from '../interfaces';
+import { StateUpdate } from '../interfaces/store';
+import { ChoiceActions } from '../actions/choices';
+import { ItemActions } from '../actions/items';
+type ActionTypes = ChoiceActions | ItemActions;
+type StateType = State['choices'];
+export default function choices(s: StateType, action: ActionTypes, context?: Options): StateUpdate<StateType>;
+export {};

data/node_modules/choices.js/public/types/src/scripts/reducers/groups.d.ts

@@ -0,0 +1,8 @@
+import { GroupActions } from '../actions/groups';
+import { State } from '../interfaces/state';
+import { StateUpdate } from '../interfaces/store';
+import { ChoiceActions } from '../actions/choices';
+type ActionTypes = ChoiceActions | GroupActions;
+type StateType = State['groups'];
+export default function groups(s: StateType, action: ActionTypes): StateUpdate<StateType>;
+export {};

data/node_modules/choices.js/public/types/src/scripts/reducers/items.d.ts

@@ -0,0 +1,9 @@
+import { ItemActions } from '../actions/items';
+import { State } from '../interfaces/state';
+import { ChoiceActions } from '../actions/choices';
+import { Options } from '../interfaces';
+import { StateUpdate } from '../interfaces/store';
+type ActionTypes = ChoiceActions | ItemActions;
+type StateType = State['items'];
+export default function items(s: StateType, action: ActionTypes, context?: Options): StateUpdate<StateType>;
+export {};

data/node_modules/choices.js/public/types/src/scripts/search/fuse.d.ts

@@ -0,0 +1,14 @@
+import { default as FuseFull, IFuseOptions } from 'fuse.js';
+import { default as FuseBasic } from 'fuse.js/basic';
+import { Options } from '../interfaces/options';
+import { Searcher, SearchResult } from '../interfaces/search';
+export declare class SearchByFuse<T extends object> implements Searcher<T> {
+    _fuseOptions: IFuseOptions<T>;
+    _haystack: T[];
+    _fuse: FuseFull<T> | FuseBasic<T> | undefined;
+    constructor(config: Options);
+    index(data: T[]): void;
+    reset(): void;
+    isEmptyIndex(): boolean;
+    search(needle: string): SearchResult<T>[];
+}

data/node_modules/choices.js/public/types/src/scripts/search/index.d.ts

@@ -0,0 +1,3 @@
+import { Options } from '../interfaces';
+import { Searcher } from '../interfaces/search';
+export declare function getSearcher<T extends object>(config: Options): Searcher<T>;

data/node_modules/choices.js/public/types/src/scripts/search/kmp.d.ts

@@ -0,0 +1,11 @@
+import { Options } from '../interfaces';
+import { Searcher, SearchResult } from '../interfaces/search';
+export declare class SearchByKMP<T extends object> implements Searcher<T> {
+    _fields: string[];
+    _haystack: T[];
+    constructor(config: Options);
+    index(data: T[]): void;
+    reset(): void;
+    isEmptyIndex(): boolean;
+    search(_needle: string): SearchResult<T>[];
+}

data/node_modules/choices.js/public/types/src/scripts/search/prefix-filter.d.ts

@@ -0,0 +1,11 @@
+import { Options } from '../interfaces';
+import { Searcher, SearchResult } from '../interfaces/search';
+export declare class SearchByPrefixFilter<T extends object> implements Searcher<T> {
+    _fields: string[];
+    _haystack: T[];
+    constructor(config: Options);
+    index(data: T[]): void;
+    reset(): void;
+    isEmptyIndex(): boolean;
+    search(_needle: string): SearchResult<T>[];
+}

data/node_modules/choices.js/public/types/src/scripts/store/store.d.ts

@@ -0,0 +1,59 @@
+import { AnyAction, Store as IStore, StoreListener } from '../interfaces/store';
+import { StateChangeSet, State } from '../interfaces/state';
+import { ChoiceFull } from '../interfaces/choice-full';
+import { GroupFull } from '../interfaces/group-full';
+export default class Store<T> implements IStore {
+    _state: State;
+    _listeners: StoreListener[];
+    _txn: number;
+    _changeSet?: StateChangeSet;
+    _context: T;
+    constructor(context: T);
+    get defaultState(): State;
+    changeSet(init: boolean): StateChangeSet;
+    reset(): void;
+    subscribe(onChange: StoreListener): this;
+    dispatch(action: AnyAction): void;
+    withTxn(func: () => void): void;
+    /**
+     * Get store object
+     */
+    get state(): State;
+    /**
+     * Get items from store
+     */
+    get items(): ChoiceFull[];
+    /**
+     * Get highlighted items from store
+     */
+    get highlightedActiveItems(): ChoiceFull[];
+    /**
+     * Get choices from store
+     */
+    get choices(): ChoiceFull[];
+    /**
+     * Get active choices from store
+     */
+    get activeChoices(): ChoiceFull[];
+    /**
+     * Get choices that can be searched (excluding placeholders or disabled choices)
+     */
+    get searchableChoices(): ChoiceFull[];
+    /**
+     * Get groups from store
+     */
+    get groups(): GroupFull[];
+    /**
+     * Get active groups from store
+     */
+    get activeGroups(): GroupFull[];
+    inTxn(): boolean;
+    /**
+     * Get single choice by it's ID
+     */
+    getChoiceById(id: number): ChoiceFull | undefined;
+    /**
+     * Get group by group id
+     */
+    getGroupById(id: number): GroupFull | undefined;
+}

data/node_modules/choices.js/public/types/src/scripts/templates.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Helpers to create HTML elements used by Choices
+ * Can be overridden by providing `callbackOnCreateTemplates` option.
+ * `Choices.defaults.templates` allows access to the default template methods from `callbackOnCreateTemplates`
+ */
+import { Templates as TemplatesInterface } from './interfaces/templates';
+declare const templates: TemplatesInterface;
+export default templates;

data/node_modules/choices.js/src/entry.js

@@ -0,0 +1,3 @@
+import Choices from './scripts/choices';
+
+export default Choices;

data/node_modules/choices.js/src/icons/cross-inverse.svg

@@ -0,0 +1 @@
+<svg width="21" height="21" viewBox="0 0 21 21" xmlns="http://www.w3.org/2000/svg"><g fill="#000" fill-rule="evenodd"><path d="M2.592.044l18.364 18.364-2.548 2.548L.044 2.592z"/><path d="M0 18.364L18.364 0l2.548 2.548L2.548 20.912z"/></g></svg>

data/node_modules/choices.js/src/icons/cross.svg

@@ -0,0 +1 @@
+<svg width="21" height="21" viewBox="0 0 21 21" xmlns="http://www.w3.org/2000/svg"><g fill="#FFF" fill-rule="evenodd"><path d="M2.592.044l18.364 18.364-2.548 2.548L.044 2.592z"/><path d="M0 18.364L18.364 0l2.548 2.548L2.548 20.912z"/></g></svg>

data/node_modules/choices.js/src/index.ts

@@ -0,0 +1,8 @@
+import Choices from './scripts/choices';
+
+export * from './scripts/interfaces';
+export * from './scripts/constants';
+export * from './scripts/defaults';
+export { default as templates } from './scripts/templates';
+
+export default Choices;

data/node_modules/choices.js/src/scripts/actions/choices.ts

@@ -0,0 +1,59 @@
+import { ChoiceFull } from '../interfaces/choice-full';
+import { ActionType } from '../interfaces';
+import { SearchResult } from '../interfaces/search';
+import { AnyAction } from '../interfaces/store';
+
+export type ChoiceActions =
+  | AddChoiceAction
+  | RemoveChoiceAction
+  | FilterChoicesAction
+  | ActivateChoicesAction
+  | ClearChoicesAction;
+
+export interface AddChoiceAction extends AnyAction<typeof ActionType.ADD_CHOICE> {
+  choice: ChoiceFull;
+}
+
+export interface RemoveChoiceAction extends AnyAction<typeof ActionType.REMOVE_CHOICE> {
+  choice: ChoiceFull;
+}
+
+export interface FilterChoicesAction extends AnyAction<typeof ActionType.FILTER_CHOICES> {
+  results: SearchResult<ChoiceFull>[];
+}
+
+export interface ActivateChoicesAction extends AnyAction<typeof ActionType.ACTIVATE_CHOICES> {
+  active: boolean;
+}
+
+/**
+ * @deprecated use clearStore() or clearChoices() instead.
+ */
+export interface ClearChoicesAction extends AnyAction<typeof ActionType.CLEAR_CHOICES> {}
+
+export const addChoice = (choice: ChoiceFull): AddChoiceAction => ({
+  type: ActionType.ADD_CHOICE,
+  choice,
+});
+
+export const removeChoice = (choice: ChoiceFull): RemoveChoiceAction => ({
+  type: ActionType.REMOVE_CHOICE,
+  choice,
+});
+
+export const filterChoices = (results: SearchResult<ChoiceFull>[]): FilterChoicesAction => ({
+  type: ActionType.FILTER_CHOICES,
+  results,
+});
+
+export const activateChoices = (active = true): ActivateChoicesAction => ({
+  type: ActionType.ACTIVATE_CHOICES,
+  active,
+});
+
+/**
+ * @deprecated use clearStore() or clearChoices() instead.
+ */
+export const clearChoices = (): ClearChoicesAction => ({
+  type: ActionType.CLEAR_CHOICES,
+});

data/node_modules/choices.js/src/scripts/actions/groups.ts

@@ -0,0 +1,14 @@
+import { GroupFull } from '../interfaces/group-full';
+import { ActionType } from '../interfaces';
+import { AnyAction } from '../interfaces/store';
+
+export type GroupActions = AddGroupAction;
+
+export interface AddGroupAction extends AnyAction<typeof ActionType.ADD_GROUP> {
+  group: GroupFull;
+}
+
+export const addGroup = (group: GroupFull): AddGroupAction => ({
+  type: ActionType.ADD_GROUP,
+  group,
+});

data/node_modules/choices.js/src/scripts/actions/items.ts

@@ -0,0 +1,34 @@
+import { ChoiceFull } from '../interfaces/choice-full';
+import { ActionType } from '../interfaces';
+import { AnyAction } from '../interfaces/store';
+
+export type ItemActions = AddItemAction | RemoveItemAction | HighlightItemAction;
+
+export interface AddItemAction extends AnyAction<typeof ActionType.ADD_ITEM> {
+  item: ChoiceFull;
+}
+
+export interface RemoveItemAction extends AnyAction<typeof ActionType.REMOVE_ITEM> {
+  item: ChoiceFull;
+}
+
+export interface HighlightItemAction extends AnyAction<typeof ActionType.HIGHLIGHT_ITEM> {
+  item: ChoiceFull;
+  highlighted: boolean;
+}
+
+export const addItem = (item: ChoiceFull): AddItemAction => ({
+  type: ActionType.ADD_ITEM,
+  item,
+});
+
+export const removeItem = (item: ChoiceFull): RemoveItemAction => ({
+  type: ActionType.REMOVE_ITEM,
+  item,
+});
+
+export const highlightItem = (item: ChoiceFull, highlighted: boolean): HighlightItemAction => ({
+  type: ActionType.HIGHLIGHT_ITEM,
+  item,
+  highlighted,
+});