govuk_publishing_components 58.1.1 → 58.2.0

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

@@ -0,0 +1,86 @@
+/* eslint-disable */
+import { ActionType, Options, State } from '../interfaces';
+import { StateUpdate } from '../interfaces/store';
+import { ChoiceActions } from '../actions/choices';
+import { ItemActions } from '../actions/items';
+import { SearchResult } from '../interfaces/search';
+import { ChoiceFull } from '../interfaces/choice-full';
+
+type ActionTypes = ChoiceActions | ItemActions;
+type StateType = State['choices'];
+
+export default function choices(s: StateType, action: ActionTypes, context?: Options): StateUpdate<StateType> {
+  let state = s;
+  let update = true;
+
+  switch (action.type) {
+    case ActionType.ADD_CHOICE: {
+      state.push(action.choice);
+      break;
+    }
+
+    case ActionType.REMOVE_CHOICE: {
+      action.choice.choiceEl = undefined;
+
+      if (action.choice.group) {
+        action.choice.group.choices = action.choice.group.choices.filter((obj) => obj.id !== action.choice.id);
+      }
+      state = state.filter((obj) => obj.id !== action.choice.id);
+      break;
+    }
+
+    case ActionType.ADD_ITEM:
+    case ActionType.REMOVE_ITEM: {
+      action.item.choiceEl = undefined;
+      break;
+    }
+
+    case ActionType.FILTER_CHOICES: {
+      // avoid O(n^2) algorithm complexity when searching/filtering choices
+      const scoreLookup: SearchResult<ChoiceFull>[] = [];
+      action.results.forEach((result) => {
+        scoreLookup[result.item.id] = result;
+      });
+
+      state.forEach((choice) => {
+        const result = scoreLookup[choice.id];
+        if (result !== undefined) {
+          choice.score = result.score;
+          choice.rank = result.rank;
+          choice.active = true;
+        } else {
+          choice.score = 0;
+          choice.rank = 0;
+          choice.active = false;
+        }
+        if (context && context.appendGroupInSearch) {
+          choice.choiceEl = undefined;
+        }
+      });
+
+      break;
+    }
+
+    case ActionType.ACTIVATE_CHOICES: {
+      state.forEach((choice) => {
+        choice.active = action.active;
+        if (context && context.appendGroupInSearch) {
+          choice.choiceEl = undefined;
+        }
+      });
+      break;
+    }
+
+    case ActionType.CLEAR_CHOICES: {
+      state = [];
+      break;
+    }
+
+    default: {
+      update = false;
+      break;
+    }
+  }
+
+  return { state, update };
+}

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

@@ -0,0 +1,32 @@
+import { GroupActions } from '../actions/groups';
+import { State } from '../interfaces/state';
+import { ActionType } from '../interfaces';
+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> {
+  let state = s;
+  let update = true;
+
+  switch (action.type) {
+    case ActionType.ADD_GROUP: {
+      state.push(action.group);
+      break;
+    }
+
+    case ActionType.CLEAR_CHOICES: {
+      state = [];
+      break;
+    }
+
+    default: {
+      update = false;
+      break;
+    }
+  }
+
+  return { state, update };
+}

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

@@ -0,0 +1,86 @@
+import { ItemActions } from '../actions/items';
+import { State } from '../interfaces/state';
+import { ChoiceActions } from '../actions/choices';
+import { ActionType, Options, PassedElementTypes } from '../interfaces';
+import { StateUpdate } from '../interfaces/store';
+import { isHtmlSelectElement } from '../lib/html-guard-statements';
+import { ChoiceFull } from '../interfaces/choice-full';
+import { updateClassList } from '../lib/utils';
+
+type ActionTypes = ChoiceActions | ItemActions;
+type StateType = State['items'];
+
+const removeItem = (item: ChoiceFull): void => {
+  const { itemEl } = item;
+  if (itemEl) {
+    itemEl.remove();
+    item.itemEl = undefined;
+  }
+};
+
+export default function items(s: StateType, action: ActionTypes, context?: Options): StateUpdate<StateType> {
+  let state = s;
+  let update = true;
+
+  switch (action.type) {
+    case ActionType.ADD_ITEM: {
+      action.item.selected = true;
+      const el = action.item.element as HTMLOptionElement | undefined;
+      if (el) {
+        el.selected = true;
+        el.setAttribute('selected', '');
+      }
+
+      state.push(action.item);
+      break;
+    }
+
+    case ActionType.REMOVE_ITEM: {
+      action.item.selected = false;
+      const el = action.item.element as HTMLOptionElement | undefined;
+      if (el) {
+        el.selected = false;
+        el.removeAttribute('selected');
+        // For a select-one, if all options are deselected, the first item is selected. To set a black value, select.value needs to be set
+        const select = el.parentElement;
+        if (select && isHtmlSelectElement(select) && select.type === PassedElementTypes.SelectOne) {
+          select.value = '';
+        }
+      }
+      // this is mixing concerns, but this is *so much faster*
+      removeItem(action.item);
+      state = state.filter((choice) => choice.id !== action.item.id);
+      break;
+    }
+
+    case ActionType.REMOVE_CHOICE: {
+      removeItem(action.choice);
+      state = state.filter((item) => item.id !== action.choice.id);
+      break;
+    }
+
+    case ActionType.HIGHLIGHT_ITEM: {
+      const { highlighted } = action;
+      const item = state.find((obj) => obj.id === action.item.id);
+      if (item && item.highlighted !== highlighted) {
+        item.highlighted = highlighted;
+        if (context) {
+          updateClassList(
+            item,
+            highlighted ? context.classNames.highlightedState : context.classNames.selectedState,
+            highlighted ? context.classNames.selectedState : context.classNames.highlightedState,
+          );
+        }
+      }
+
+      break;
+    }
+
+    default: {
+      update = false;
+      break;
+    }
+  }
+
+  return { state, update };
+}

data/node_modules/choices.js/src/scripts/search/fuse.ts

@@ -0,0 +1,59 @@
+// eslint-disable-next-line import/no-named-default
+import { default as FuseFull, IFuseOptions } from 'fuse.js';
+// eslint-disable-next-line import/no-named-default
+import { default as FuseBasic } from 'fuse.js/basic';
+import { Options } from '../interfaces/options';
+import { Searcher, SearchResult } from '../interfaces/search';
+import { searchFuse } from '../interfaces/build-flags';
+
+export class SearchByFuse<T extends object> implements Searcher<T> {
+  _fuseOptions: IFuseOptions<T>;
+
+  _haystack: T[] = [];
+
+  _fuse: FuseFull<T> | FuseBasic<T> | undefined;
+
+  constructor(config: Options) {
+    this._fuseOptions = {
+      ...config.fuseOptions,
+      keys: [...config.searchFields],
+      includeMatches: true,
+    };
+  }
+
+  index(data: T[]): void {
+    this._haystack = data;
+    if (this._fuse) {
+      this._fuse.setCollection(data);
+    }
+  }
+
+  reset(): void {
+    this._haystack = [];
+    this._fuse = undefined;
+  }
+
+  isEmptyIndex(): boolean {
+    return !this._haystack.length;
+  }
+
+  search(needle: string): SearchResult<T>[] {
+    if (!this._fuse) {
+      if (searchFuse === 'full') {
+        this._fuse = new FuseFull<T>(this._haystack, this._fuseOptions);
+      } else {
+        this._fuse = new FuseBasic<T>(this._haystack, this._fuseOptions);
+      }
+    }
+
+    const results = this._fuse.search(needle);
+
+    return results.map((value, i): SearchResult<T> => {
+      return {
+        item: value.item,
+        score: value.score || 0,
+        rank: i + 1, // If value.score is used for sorting, this can create non-stable sorts!
+      };
+    });
+  }
+}

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

@@ -0,0 +1,17 @@
+import { Options } from '../interfaces';
+import { Searcher } from '../interfaces/search';
+import { SearchByPrefixFilter } from './prefix-filter';
+import { SearchByFuse } from './fuse';
+import { SearchByKMP } from './kmp';
+import { searchFuse, searchKMP } from '../interfaces/build-flags';
+
+export function getSearcher<T extends object>(config: Options): Searcher<T> {
+  if (searchFuse && !searchKMP) {
+    return new SearchByFuse<T>(config);
+  }
+  if (searchKMP) {
+    return new SearchByKMP<T>(config);
+  }
+
+  return new SearchByPrefixFilter<T>(config);
+}

data/node_modules/choices.js/src/scripts/search/kmp.ts

@@ -0,0 +1,87 @@
+import { Options } from '../interfaces';
+import { Searcher, SearchResult } from '../interfaces/search';
+
+function kmpSearch(pattern: string, text: string): number {
+  if (pattern.length === 0) {
+    return 0; // Immediate match
+  }
+
+  // Compute longest suffix-prefix table
+  const lsp = [0]; // Base case
+  for (let i = 1; i < pattern.length; i++) {
+    let j = lsp[i - 1]; // Start by assuming we're extending the previous LSP
+    while (j > 0 && pattern.charAt(i) !== pattern.charAt(j)) {
+      j = lsp[j - 1];
+    }
+    if (pattern.charAt(i) === pattern.charAt(j)) {
+      j++;
+    }
+    lsp.push(j);
+  }
+
+  // Walk through text string
+  let j = 0; // Number of chars matched in pattern
+  for (let i = 0; i < text.length; i++) {
+    while (j > 0 && text.charAt(i) !== pattern.charAt(j)) {
+      j = lsp[j - 1]; // Fall back in the pattern
+    }
+    if (text.charAt(i) === pattern.charAt(j)) {
+      j++; // Next char matched, increment position
+      if (j === pattern.length) {
+        return i - (j - 1);
+      }
+    }
+  }
+
+  return -1; // Not found
+}
+
+export class SearchByKMP<T extends object> implements Searcher<T> {
+  _fields: string[];
+
+  _haystack: T[] = [];
+
+  constructor(config: Options) {
+    this._fields = config.searchFields;
+  }
+
+  index(data: T[]): void {
+    this._haystack = data;
+  }
+
+  reset(): void {
+    this._haystack = [];
+  }
+
+  isEmptyIndex(): boolean {
+    return !this._haystack.length;
+  }
+
+  search(_needle: string): SearchResult<T>[] {
+    const fields = this._fields;
+    if (!fields || !fields.length || !_needle) {
+      return [];
+    }
+    const needle = _needle.toLowerCase();
+
+    const results: SearchResult<T>[] = [];
+
+    let count = 0;
+    for (let i = 0, j = this._haystack.length; i < j; i++) {
+      const obj = this._haystack[i];
+      for (let k = 0, l = this._fields.length; k < l; k++) {
+        const field = this._fields[k];
+        if (field in obj && kmpSearch(needle, (obj[field] as string).toLowerCase()) !== -1) {
+          results.push({
+            item: obj[field],
+            score: count,
+            rank: count + 1,
+          });
+          count++;
+        }
+      }
+    }
+
+    return results;
+  }
+}

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

@@ -0,0 +1,42 @@
+import { Options } from '../interfaces';
+import { Searcher, SearchResult } from '../interfaces/search';
+
+export class SearchByPrefixFilter<T extends object> implements Searcher<T> {
+  _fields: string[];
+
+  _haystack: T[] = [];
+
+  constructor(config: Options) {
+    this._fields = config.searchFields;
+  }
+
+  index(data: T[]): void {
+    this._haystack = data;
+  }
+
+  reset(): void {
+    this._haystack = [];
+  }
+
+  isEmptyIndex(): boolean {
+    return !this._haystack.length;
+  }
+
+  search(_needle: string): SearchResult<T>[] {
+    const fields = this._fields;
+    if (!fields || !fields.length || !_needle) {
+      return [];
+    }
+    const needle = _needle.toLowerCase();
+
+    return this._haystack
+      .filter((obj) => fields.some((field) => field in obj && (obj[field] as string).toLowerCase().startsWith(needle)))
+      .map((value, index): SearchResult<T> => {
+        return {
+          item: value,
+          score: index,
+          rank: index + 1,
+        };
+      });
+  }
+}

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

@@ -0,0 +1,184 @@
+import { AnyAction, Reducer, 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';
+import items from '../reducers/items';
+import groups from '../reducers/groups';
+import choices from '../reducers/choices';
+
+type ReducerList = { [K in keyof State]: Reducer<State[K]> };
+
+const reducers: ReducerList = {
+  groups,
+  items,
+  choices,
+} as const;
+
+export default class Store<T> implements IStore {
+  _state: State = this.defaultState;
+
+  _listeners: StoreListener[] = [];
+
+  _txn: number = 0;
+
+  _changeSet?: StateChangeSet;
+
+  _context: T;
+
+  constructor(context: T) {
+    this._context = context;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  get defaultState(): State {
+    return {
+      groups: [],
+      items: [],
+      choices: [],
+    };
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  changeSet(init: boolean): StateChangeSet {
+    return {
+      groups: init,
+      items: init,
+      choices: init,
+    };
+  }
+
+  reset(): void {
+    this._state = this.defaultState;
+    const changes = this.changeSet(true);
+    if (this._txn) {
+      this._changeSet = changes;
+    } else {
+      this._listeners.forEach((l) => l(changes));
+    }
+  }
+
+  subscribe(onChange: StoreListener): this {
+    this._listeners.push(onChange);
+
+    return this;
+  }
+
+  dispatch(action: AnyAction): void {
+    const state = this._state;
+    let hasChanges = false;
+    const changes = this._changeSet || this.changeSet(false);
+
+    Object.keys(reducers).forEach((key: string) => {
+      const stateUpdate = (reducers[key] as Reducer<unknown>)(state[key], action, this._context);
+      if (stateUpdate.update) {
+        hasChanges = true;
+        changes[key] = true;
+        state[key] = stateUpdate.state;
+      }
+    });
+
+    if (hasChanges) {
+      if (this._txn) {
+        this._changeSet = changes;
+      } else {
+        this._listeners.forEach((l) => l(changes));
+      }
+    }
+  }
+
+  withTxn(func: () => void): void {
+    this._txn++;
+    try {
+      func();
+    } finally {
+      this._txn = Math.max(0, this._txn - 1);
+
+      if (!this._txn) {
+        const changeSet = this._changeSet;
+        if (changeSet) {
+          this._changeSet = undefined;
+          this._listeners.forEach((l) => l(changeSet));
+        }
+      }
+    }
+  }
+
+  /**
+   * Get store object
+   */
+  get state(): State {
+    return this._state;
+  }
+
+  /**
+   * Get items from store
+   */
+  get items(): ChoiceFull[] {
+    return this.state.items;
+  }
+
+  /**
+   * Get highlighted items from store
+   */
+  get highlightedActiveItems(): ChoiceFull[] {
+    return this.items.filter((item) => item.active && item.highlighted);
+  }
+
+  /**
+   * Get choices from store
+   */
+  get choices(): ChoiceFull[] {
+    return this.state.choices;
+  }
+
+  /**
+   * Get active choices from store
+   */
+  get activeChoices(): ChoiceFull[] {
+    return this.choices.filter((choice) => choice.active);
+  }
+
+  /**
+   * Get choices that can be searched (excluding placeholders or disabled choices)
+   */
+  get searchableChoices(): ChoiceFull[] {
+    return this.choices.filter((choice) => !choice.disabled && !choice.placeholder);
+  }
+
+  /**
+   * Get groups from store
+   */
+  get groups(): GroupFull[] {
+    return this.state.groups;
+  }
+
+  /**
+   * Get active groups from store
+   */
+  get activeGroups(): GroupFull[] {
+    return this.state.groups.filter((group) => {
+      const isActive = group.active && !group.disabled;
+      const hasActiveOptions = this.state.choices.some((choice) => choice.active && !choice.disabled);
+
+      return isActive && hasActiveOptions;
+    }, []);
+  }
+
+  inTxn(): boolean {
+    return this._txn > 0;
+  }
+
+  /**
+   * Get single choice by it's ID
+   */
+  getChoiceById(id: number): ChoiceFull | undefined {
+    return this.activeChoices.find((choice) => choice.id === id);
+  }
+
+  /**
+   * Get group by group id
+   */
+  getGroupById(id: number): GroupFull | undefined {
+    return this.groups.find((group) => group.id === id);
+  }
+}