ids-enterprise-typings 18.6.0-dev.8 → 18.6.0

package/about/soho-about.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Soho About Dialog Control.
+ *
+ * This file contains the Typescript mappings for the public
+ * interface of the Soho jQuery about dialog control.
+ *
+ * Only the public interface consumable by the Angular
+ * Soho Component is included in this file.
+ *
+ * The corresponding Soho control can be found in about.js.
+ */
+
+/**
+ * Soho About Dialog configuration options
+ *
+ * See the jQuery control for the defaults.
+ */
+interface SohoAboutOptions {
+  /** The Main Application Name to display in the heading */
+  appName?: string;
+
+  /** Additional Text content to display at the top of the about dialog */
+  content?: string;
+
+  /** The year displayed in the copyright, defaults to current year. */
+  copyrightYear?: string;
+
+  /** Determines whether or not to display device information (Browser, Platform, Locale, Cookies Enabled) */
+  deviceSpecs?: boolean;
+
+  /** Additional product name information to display */
+  productName?: string;
+
+  /** Add the Legal Approved Infor Copyright Text */
+  useDefaultCopyright?: boolean;
+
+  /** Semantic Version Number for example (4.0.0) */
+  version?: string;
+
+  /** Add extra attributes like id's to the component **/
+  attributes?: Array<Object> | Object;
+}
+
+/**
+ * This interface represents the Api exposed by the
+ * soho control.
+ *
+ * Only public members are exposed on this interface.
+ */
+interface SohoAboutStatic {
+
+  /** Element. */
+  element: JQuery;
+
+  /**
+   * Close the about dialog.
+   *
+   */
+  close(): void;
+
+  /**
+   * Releases all resources managed by the about dialog.
+   */
+  destroy(): void;
+}
+
+/**
+ * Integration with jQuery
+ */
+interface JQuery<TElement = HTMLElement> extends Iterable<TElement> {
+  about(options: SohoAboutOptions): JQuery;
+}
+
+interface JQueryStatic {
+  about: SohoAboutStatic;
+}

package/accordion/soho-accordion.d.ts

@@ -0,0 +1,229 @@
+/**
+ * Soho Accordion Typings.
+ *
+ * The Accordion is a grouped set of collapsible panels used to navigate sections of
+ * related content. Each panel consists of two levels: the top level identifies the
+ * category or section header, and the second level provides the associated options.
+ */
+
+type SohoAccordionExpanderType = 'classic' | 'plus-minus' | 'chevron';
+
+type SohoAccordionDefaultFocusBehaviorCallback = () => void;
+
+type SohoAccordionHeaderGroup = any; // JQuery<HTMLElement>
+
+type SohoAccordionHeaderExpanderButtonGroup = any; // JQuery<HTMLElement>
+
+type SohoAccordionHeaderAnchorGroup = any; // JQuery<HTMLElement>
+
+type SohoAccordionHeaderAnyGroup = SohoAccordionHeaderGroup | SohoAccordionHeaderExpanderButtonGroup | SohoAccordionHeaderAnchorGroup;
+
+type SohoAccordionNavDirection = 0 | -1 | 1;
+
+/**
+ * Soho Accordion data representation types
+ * These can be used to work with the results of `.toData()`
+ */
+
+type SohoAccordionData = Array<SohoAccordionSectionData> | Array<SohoAccordionHeaderData>;
+
+type SohoAccordionSectionData = {
+  index: string,
+  type: 'section',
+  children?: Array<SohoAccordionHeaderData | SohoAccordionContentData>,
+};
+
+type SohoAccordionContentData = {
+  index: string,
+  type: 'content',
+  content?: string,
+  contentText?: string
+};
+
+type SohoAccordionHeaderData = {
+  index: string,
+  type: 'header',
+  text?: string,
+  icon?: string,
+  children?: Array<SohoAccordionHeaderData | SohoAccordionContentData>
+};
+
+/**
+ * Soho Accordion Control Options
+ */
+interface SohoAccordionOptions {
+  /**
+   * Provides a mechanism for controlling the behavior of accordion header focus.
+   * By default, the built-in behavior is used (ability to focus headers/expanders independently).
+   */
+  accordionFocusCallback?: (header: JQuery<HTMLElement>, defaultFocusBehaviorCallback?: SohoAccordionDefaultFocusBehaviorCallback) => void;
+
+  /**
+   * If set to true, allows only one pane of the Accordion to be open at a time.
+   * If an Accordion pane is open, and that pane contains sub-headers,
+   * only one of the pane's sub-headers can be open at a time. (default true)
+   */
+  allowOnePane?: boolean;
+
+  /**
+   * Displays a "Chevron" icon that sits off to the right-most side of a top-level
+   * accordion header.  Used in place of an Expander (+/-) if enabled.
+   */
+  displayChevron?: boolean;
+
+  /**
+   * Changes the iconography used in accordion header expander buttons.
+   */
+  expanderDisplay?: SohoAccordionExpanderType;
+
+  /**
+   * Set to false if routing is handled externally.
+   */
+  rerouteOnLinkClick?: boolean;
+
+  /**
+   * Add a alert badge to the accordion header (used for App menu)
+   */
+  notificationBadge?: boolean;
+
+  /**
+   * A callback function that when implemented provided a call back for "ajax loading"
+   * of tab contents on open.
+   */
+  source?: Function;
+
+  /**
+   *  Set true to use panels with header selection
+   */
+  hasPanels?: boolean;
+
+  /**
+   * Sets the color scheme to inverse
+   */
+  inverse?: boolean;
+
+  /**
+   * Sets the color scheme to alternate
+   */
+  alternate?: boolean;
+
+  /**
+   * Enables tooltips for longer text that is handled with ellipsis
+   */
+  enableTooltips?: boolean;
+}
+
+/**
+ * This interface represents the public API exposed by the Soho Accordion
+ */
+interface SohoAccordionStatic {
+  /** Access to the control's options block. */
+  settings: SohoAccordionOptions;
+
+  /** Calls the `source` method passed via settings */
+  callSource(anchor: SohoAccordionHeaderAnchorGroup, animationCallback: () => void): void;
+
+  /** Collapses all panels. */
+  collapseAll(): void;
+
+  /** Expands all panels. */
+  expandAll(): void;
+
+  /** Expands one or a group of panels */
+  expand(header: SohoAccordionHeaderGroup | string): void;
+
+  /** Collapses one or a group of panels */
+  collapse(header: SohoAccordionHeaderGroup | string): void;
+
+  /** Disables the accordion from reacting to events. */
+  disable(): void;
+
+  /** Enables the accordion. */
+  enable(): void;
+
+  /** Checks if a particular header is disabled, or if the entire accordion is disabled. */
+  isDisabled(header: SohoAccordionHeaderGroup): boolean;
+
+  /** Checks if an Accordion Section is currently expanded. */
+  isExpanded(header: SohoAccordionHeaderGroup): boolean;
+
+  /** Toggles the exanded state of the selected header. */
+  toggle(header: SohoAccordionHeaderGroup): boolean;
+
+  /**
+   * Gets the current contents of this accordion and creates a JSON-like representation of the structure.
+   * For full JSON compatibility, don't use the `addElementReference` flag.
+   **/
+  toData(flatten?: boolean, addElementReference?: boolean): SohoAccordionData;
+
+  /** Makes an accordion header appear with a "selected" state */
+  select(element?: SohoAccordionHeaderAnyGroup): void;
+
+  /** Makes an accordion header appear with a "deselected" state */
+  deselect(element?: SohoAccordionHeaderAnyGroup): void;
+
+  /** Makes all accordion headers deselected */
+  deselectAll(): void;
+
+  /** Gets a reference to currently-selected accordion headers */
+  getSelected(): SohoAccordionHeaderGroup;
+
+  /** Determines if an Accordion Header is disabled */
+  isDisabled(header: SohoAccordionHeaderGroup): boolean;
+
+  /** "Visually" filters accordion headers (elements are not added/removed but temporarily hidden by CSS if filtered out) */
+  filter(headers?: SohoAccordionHeaderGroup): void;
+
+  /** Resets a previously-applied filter */
+  unfilter(headers?: SohoAccordionHeaderGroup): void;
+
+  /** Determines if an Accordion Header is currently visually filtered out */
+  isFiltered(header: SohoAccordionHeaderGroup): boolean;
+
+  /** Determines if animation is currently happening on accordion panes (controls some behavior internally) */
+  isAnimating: boolean;
+
+  /** Programmatically navigates to the next-available accordion header (down) */
+  nextHeader(element: SohoAccordionHeaderAnyGroup, noDescend?: boolean): void;
+
+  /** Programmatically navigates to the previous-available accordion header (up) */
+  prevHeader(element: SohoAccordionHeaderAnyGroup, noDescend?: boolean): void;
+
+  /** Programmatically navigates to the next-available accordion header (down) */
+  ascend(element: SohoAccordionHeaderGroup, direction?: SohoAccordionNavDirection): void;
+
+  /** Programmatically navigates to the previous-available accordion header (up) */
+  descend(element: SohoAccordionHeaderGroup, direction?: SohoAccordionNavDirection): void;
+
+  /** Programmatically focuses the correct element within an accordion header (based on previously-focused elements) */
+  focusOriginalType(header: SohoAccordionHeaderGroup): void;
+
+  /** Updates the accordion with any new settings. */
+  updated(headers?: SohoAccordionHeaderGroup, settings?: SohoAccordionOptions): void;
+
+  /** Performs a teardown of the jQuery component API (does not remove the component instance) */
+  teardown(): void;
+
+  /** Destroys the control on completion. (Tears down and removes the component instance) */
+  destroy(): void;
+}
+
+/**
+ * JQuery Integration
+ */
+interface JQueryStatic {
+  accordion: any;
+}
+
+/**
+ * jQuery integration.
+ */
+interface JQuery<TElement = HTMLElement> extends Iterable<TElement> {
+  accordion(options?: SohoAccordionOptions): SohoAccordionStatic;
+  on(events: string,
+    handler: JQuery.EventHandlerBase<TElement, SohoAccordionEvent>): this;
+}
+
+interface SohoAccordionEvent extends JQuery.TriggeredEvent {
+  anchor: HTMLAnchorElement;
+}

package/actionsheet/soho-actionsheet.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Soho Actionsheet.
+ *
+ * This file contains the TypeScript mappings for the public
+ * interface of the Soho Actionsheet control.
+ */
+
+/**
+ * Actionsheet Options
+ */
+
+type SohoActionsheetDisplay = false | 'responsive' | 'always';
+
+type SohoActionsheetTrayBackgroundColors = 'slate' | 'ruby' | 'amber' | 'emerald' | 'azure' | 'turquoise' | 'amethyst';
+
+interface SohoActionsheetOptions {
+  actions?: Array<SohoActionsheetActions>;
+  autoFocus?: boolean;
+  breakpoint?: string;
+  displayAsActionSheet?: SohoActionsheetDisplay;
+  overlayOpacity?: number;
+  onSelect?: Function;
+  onCancel?: Function;
+  tray?: boolean;
+  trayOpts?: SohoActionsheetTrayOptions;
+  showCancelButton?: boolean;
+  attributes?: Array<Object> | Object;
+}
+
+interface SohoActionsheetTrayOptions {
+  text?: string;
+  icon?: string;
+  backgroundColor?: SohoActionsheetTrayBackgroundColors;
+}
+
+interface SohoActionsheetActions {
+  icon?: string;
+  text?: string;
+}
+
+interface SohoActionsheetStatic {
+  settings: SohoActionsheetOptions;
+
+  /** Returns true if the Action Sheet is currently visible */
+  get visible(): boolean;
+
+  /** Returns true if the Action Sheet is currently visible */
+  get actionElems(): boolean;
+
+  /** Returns attached Popupmenu API, if available */
+  get popupmenuAPI(): SohoPopupMenuOptions;
+
+  /** Returns true if there is a currently-open Popupmenu attached to the trigger button */
+  get hasOpenPopupMenu(): boolean;
+
+  /** Returns {boolean} whether or not this Action Sheet instance should currently display in
+   * full size mode (uses the settings, but determined at runtime)
+   * */
+  get currentlyNeedsActionSheet(): boolean;
+
+  /** Opens the Action Sheet */
+  open(): void;
+
+  /** Opens a simple Popupmenu containing the same actions as the sheet. */
+  openPopupMenu(): void;
+
+  /** Tears down and removes any added markup and events. */
+  destroy(): void;
+
+  /** Triggers a UI Resync. */
+  updated(settings?: SohoActionsheetOptions): void;
+}
+
+/** jQuery Integration */
+interface jQueryStatic {
+  actionsheet: SohoActionsheetStatic;
+}
+
+interface JQuery<TElement = HTMLElement> extends Iterable<TElement> {
+  actionsheet(options?: SohoActionsheetOptions): JQuery;
+}

package/alert/soho-alert.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Soho Alert.
+ *
+ * This file contains the Typescript mappings for the public
+ * interface of the Soho jQuery alert control.
+ */
+
+type SohoAlertType = 'error' | 'alert' | 'success' | 'info' | 'icon' | undefined;
+
+interface SohoAlertOptions {
+  /** */
+  message?: string;
+
+  /** */
+  inline?: boolean;
+
+  /** */
+  type?: SohoAlertType;
+
+  /**
+   * If true, does not display control border color, control text color, and control icon color.
+   */
+  isAlert?: boolean;
+
+  /**
+   * If true, events will be triggered
+   */
+  triggerEvents?: boolean;
+
+  /** */
+  icon?: string;
+
+  id?: string;
+}
+
+/**
+ * This interface represents the public API exposed by the
+ * Alert.
+ */
+interface SohoAlertStatic {
+  /** Access to the control's options block. */
+  settings: SohoAlertOptions;
+
+  /** Tears down the control and recreates it. */
+  updated(): void;
+
+  /** Destructor. */
+  destroy(): void;
+}
+
+interface JQuery<TElement = HTMLElement> extends Iterable<TElement> {
+  addError(options?: SohoAlertOptions): JQuery;
+
+  addMessage(options?: SohoAlertOptions): JQuery;
+
+  getErrorMessage(options?: SohoAlertOptions): string;
+
+  getMessage(options?: SohoAlertOptions): string;
+
+  removeError(options?: SohoAlertOptions): JQuery;
+
+  removeMessage(options?: SohoAlertOptions): JQuery;
+
+  scrollIntoView(alignToTop?: boolean, options?: SohoAlertOptions): void;
+}

package/application-menu/soho-application-menu.d.ts

@@ -0,0 +1,135 @@
+/// <reference path='../accordion/soho-accordion.d.ts' />
+/// <reference path='../searchfield/soho-searchfield.d.ts' />
+
+/**
+ * Soho Application Menu.
+ *
+ * This file contains the Typescript mappings for the public
+ * interface of the Soho jQuery applicationmenu control.
+ */
+
+/**
+ * Application Menu Options
+ */
+type SohoApplicationMenuBreakPoint =
+  'phone' |
+  'slim' |
+  'phablet' |
+  'phone-to-tablet' |
+  'wide-tablet' |
+  'tablet-to-desktop' |
+  'desktop-to-extralarge' | undefined;
+
+type SohoApplicationMenuExpandSwitcherFunction = (
+  applicationMenu: any,
+  element: HTMLElement,
+  settings: any
+) => void;
+
+type SohoApplicationMenuCollapseSwitcherFunction = (
+  applicationMenu: any,
+  element: HTMLElement,
+  settings: any
+) => void;
+
+interface SohoApplicationMenuOptions {
+  /** Defines the point at which the application should be displayed - depends on device. */
+  breakpoint: SohoApplicationMenuBreakPoint;
+
+  /** Is this application menu filterable. */
+  filterable?: boolean;
+
+  /** Is this application menu resizable. */
+  resizable?: boolean;
+
+  /** Is this application menu resizable. */
+  savePosition?: boolean;
+
+  /** Open the menu when the screen width is larger that the breakpoint. */
+  openOnLarge: boolean | undefined;
+
+  /** Allows the menu to become closed after an actionable header has been selected */
+  dismissOnClickMobile: boolean | undefined;
+
+  /** The controls which can trigger the display state of the application menu. */
+  triggers: any[];
+
+  onExpandSwitcher?: SohoApplicationMenuExpandSwitcherFunction;
+
+  onCollapseSwitcher?: SohoApplicationMenuCollapseSwitcherFunction;
+}
+
+/**
+ * Application Menu Api
+ */
+interface SohoApplicationMenuStatic {
+  /** Control settings. */
+  settings: SohoApplicationMenuOptions;
+
+  /** Accordion element */
+  accordionEl: HTMLElement;
+
+  /** Searchfield element, if present */
+  searchEl?: HTMLElement | null;
+
+  /** Searchfield API, if present */
+  searchAPI?: SohoSearchFieldStatic;
+
+  /**
+   * Opens the application menu.
+   *
+   * param noFocus - if set the current focus is not modified.
+   */
+  openMenu(noFocus?: boolean, userOpened?: boolean, openedByClass?: boolean): void;
+
+  /**
+   * Closes the application menu.
+   */
+  closeMenu(): void;
+
+  /**
+   * Add and remove application nav menu triggers.
+   *
+   * @param triggers - list of triggers
+   * @param remove - if set the triggers will be removed.
+   * @param norebuild - if set this control's events won't automatically be rebound to include
+   *                    the new triggers.
+   */
+  modifyTriggers(triggers: any[], remove: boolean, norebusild: boolean): void;
+
+  /**
+   * Updates the control based on the new settings.
+   */
+  updated(): void;
+
+  /**
+   * Closes the panel area controlled by switcher
+   */
+  closeSwitcherPanel(): void;
+
+  /**
+   * Has this control got the defined class.
+   *
+   * @param clazz - the class to check for.
+   */
+  hasClass(clazz: string): boolean;
+
+  /**
+   * Checks if the application menu is open.
+   *
+   */
+  isOpen(): boolean;
+
+  /**
+   * Cleans up any markup.
+   */
+  destroy(): void;
+}
+
+interface JQueryStatic {
+  applicationmenu: SohoApplicationMenuStatic;
+}
+
+interface JQuery<TElement = HTMLElement> extends Iterable<TElement> {
+  applicationmenu(options?: SohoApplicationMenuOptions): JQuery;
+}

package/arrange/soho-arrange.d.ts

@@ -0,0 +1,24 @@
+interface SohoArrangeOptions {
+  handle?: string; // The CSS class name of the handle element to connect.
+  itemsSelector?: string; // The CSS selector to match all the sortable elements.
+  connectWith?: boolean; // Optional CSS Selector to connect with when using two lists.
+  isVisualItems?: boolean; // Use only index of visual items to trigger.
+  placeholder?: string; // The html for the element that appears while dragging.
+  placeholderCssClass?: string; // The class to add to the ghost element that is being dragged.
+  useItemDimensions?: boolean; // If true, use item's dimensions to placeholder.
+}
+
+interface SohoArrangeStatic {
+  settings: SohoArrangeOptions;
+  updated: Function;
+  destroy: Function;
+}
+
+interface JQuery<TElement = HTMLElement> extends Iterable<TElement> {
+  arrange(options?: SohoArrangeOptions): JQuery;
+}
+
+interface SohoArrangeEvent {
+  event: JQuery.TriggeredEvent;
+  status?: any;
+}

package/autocomplete/soho-autocomplete.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Soho Autocomplete.
+ *
+ * This file contains the Typescript mappings for the public
+ * interface of the Soho jQuery Autocomplete control.
+ */
+
+/**
+ * Autocomplete Options
+ */
+interface SohoAutoCompleteOptions {
+  /** Defines the data to use, must be specified for this component. */
+  source?: SohoAutoCompleteSource;
+
+  /** Object is passed into the source method, and augmented with parameters. */
+  sourceArguments?: string;
+
+  /** Menu template, appropriate markup is expected. */
+  template?: string;
+
+  /** if true, causes filter results that don't match case to be thrown out */
+  caseSensitive?: boolean;
+
+  /** Filters based on the first character('startsWidth') of the string, or the entire string('contains') */
+  filterMode?: SohoAutoCompleteFilterMode;
+
+  /** Delay between key strokes on the keypad before the end of typing */
+  delay?: number;
+
+  /** Width of the open menu */
+  width?: number | string;
+
+  /** Offset, the left or top offset */
+  offset?: SohoAutoCompleteOffset;
+
+  /** Selects first item menu */
+  autoSelectFirstItem?: boolean;
+
+  /** Add extra attributes like id's to the component **/
+  attributes?: Array<Object> | Object;
+}
+
+type SohoAutoCompleteSource = Object[] | string | Object | SohoAutoCompleteSourceFunction;
+
+type SohoAutoCompleteResponseFunction = (term: string, data: any[]) => void;
+
+type SohoAutoCompleteSourceFunction = (term: string, response: SohoAutoCompleteResponseFunction) => void;
+
+// can be 'wordStartsWith', 'contains', 'keyword', or 'phraseStartsWith'
+type SohoAutoCompleteFilterMode = string;
+
+type SohoAutoCompleteWidth = number | string;
+
+interface SohoAutoCompleteOffset {
+  top?: number | string;
+  left?: number | string;
+}
+
+interface SohoAutoCompleteEvent {
+  elem?: HTMLElement;
+  value?: string;
+}
+
+ interface SohoAutoCompleteStatic {
+   /** Destructor. */
+   destroy(): void;
+
+   /** Clear. */
+   clear(): void;
+
+   /** Disable the control. */
+   disable(): void;
+
+   /** Enable the control. */
+   enable(): void;
+
+   /** Mark the control as readonly. */
+   readonly(): void;
+
+   /** Mark the control as updated.  */
+   updated(): void;
+ }
+
+interface JQueryStatic {
+  autocomplete: SohoAutoCompleteStatic;
+}
+
+interface JQuery<TElement = HTMLElement> extends Iterable<TElement> {
+  autocomplete(options?: SohoAutoCompleteOptions): JQuery;
+
+  on(events: 'beforeopen', handler: JQuery.EventHandlerBase<any, SohoAutoCompleteEvent>): this;
+}