generic-ui-core/dist/index.d.ts

A support library for generic UI components.

declare module 'generic-ui-core' {
  export const FieldTypes: Readonly<{
    DEL_LAYER: 'Layer';
    DEL_FIELD: 'Field';
    DEL_SELECT: 'Select';
    DEL_OPTION: 'Option';
    F_CHECKBOX: 'checkbox';
    F_DATE: 'date';
    F_DATETIME: 'datetime';
    F_DATETIME_RANGE: 'datetime-range';
    F_DRAG: 'drag';
    F_DRAG_ELEMENT: 'drag_element';
    F_DRAG_MOLECULE: 'drag_molecule';
    F_DRAG_SAMPLE: 'drag_sample';
    F_DRAG_REACTION: 'drag_reaction';
    F_DUMMY: 'dummy';
    F_FORMULA_FIELD: 'formula-field';
    F_INPUT_GROUP: 'input-group';
    F_INTEGER: 'integer';
    F_LABEL: 'label';
    F_NUMBER: 'number';
    F_ONTOLOGY_SELECT: 'ontology-select';
    F_SELECT: 'select';
    F_SELECT_MULTI: 'select-multi';
    F_SYS_REACTION: 'sys-reaction';
    F_SYSTEM_DEFINED: 'system-defined';
    F_TABLE: 'table';
    F_TEXT: 'text';
    F_TEXTAREA: 'textarea';
    F_TEXT_FORMULA: 'text-formula';
    F_UPLOAD: 'upload';
    F_WF_NEXT: 'wf-next';
    V_BOOLEAN: 'boolean';
    V_UNDEFINED: 'undefined';
  }>;

  export const OptionMaps: Readonly<{
    TBL_OPTS_MOLECULE: Array<{
      label: 'InChiKey' | 'SMILES' | 'IUPAC' | 'Mass';
      value: 'inchikey' | 'smiles' | 'iupac' | 'molecular_weight';
    }>;
    TBL_OPTS_SAMPLE: Array<{
      label: 'Name' | 'Ext. Label' | 'Mass';
      value: 'name' | 'external_label' | 'molecular_weight';
    }>;
  }>;

  export const WorkflowTypes: Readonly<{
    ND_INPUT: 'input';
    ND_OUTPUT: 'output';
    ND_DEFAULT: 'default';
  }>;

  export interface Element {
    properties_template: {
      layers: Record<
        string,
        {
          fields: Array<{
            type: string;
            value?: any;
            sub_fields?: Array<{
              type: string;
              value: string;
            }>;
          }>;
        }
      >;
    };
  }

  // Common functions
  export function downloadFile(file: { contents: string; name: string }): void;
  export function swapAryEls<T>(ary: T[], idx1: number, idx2: number): T[];
  export function buildTS(
    ontology: { iri: string; ontology_prefix: string; type: string } | null
  ): string | null;
  export function buildTSS(q: string | null): string | null;

  // Condition Operator types
  export interface CondOperatorOption {
    label: 'Match One' | 'Match All' | 'Match None';
    value: 0 | 1 | 9;
  }
  export const defaultCondOperator: 1;
  export const condOperatorOptions: CondOperatorOption[];
  export const getCondOperator: Record<0 | 1 | 9, string>;

  // Order utility functions
  export function moveLayer(
    layers: Record<string, { position: number; [key: string]: any }>,
    sourceKey: string,
    targetKey: string
  ): Record<string, { position: number; [key: string]: any }>;

  export function moveField(
    fields: Array<{ field: string; position: number; [key: string]: any }>,
    sourceKey: string,
    targetKey: string
  ): Array<{ field: string; position: number; [key: string]: any }>;

  // Template functions
  export function clsInputGroup(el: Element): Element;
  export function replaceData(data: string, spec?: string): string;
  export function resetProperties(props: { layers: Record<string, any> }): {
    layers: Record<string, any>;
  };
  export function absOlsTermId(val: string): string;
  export function absOlsTermLabel(val: string): string;
  export function showProperties(dataObj: any, layers: any): any[];
  export function orgLayerObject(layers?: any[]): Record<string, any>;
  export function isLayerVisible(
    layer: {
      cond_fields?: Array<any>;
    },
    layers: Record<string, any>
  ): boolean;

  // Unit functions
  export function getUnitSystem(externalUnits?: Record<string, any>): any[];
  export function genUnit(type: string, unit: string): Record<string, string>;
  export function genUnits(type: string): Array<Record<string, string>>;
  export function unitConversion(
    value: number,
    fromUnit: string,
    toUnit: string
  ): number;
  export function reUnit(value: string): string;

  // Workflow functions
  export function isLayerInWF(element: Element, layerKey: string): boolean;
  export function storeFlow(props: { elements: Element[] }): any[];
}