@esrf/daiquiri-lib 0.0.2-alpha.1 → 0.0.2-alpha.2

package/dist/index.d.ts

@@ -0,0 +1,387 @@
+/// <reference types="react" />
+import * as react from 'react';
+import { ReactElement, PropsWithChildren, ReactChild, ChangeEvent, KeyboardEvent } from 'react';
+
+interface HardwareError {
+    property: string;
+    exception: string;
+    traceback: string;
+}
+interface HardwareSchemaDescription {
+    properties: {
+        additionalProperties?: boolean;
+        properties: {
+            [property: string]: any;
+        };
+        type: string;
+        uischema: {
+            position: [Record<string, unknown>];
+        };
+        uiorder?: string[];
+    };
+    callables: {
+        additionalProperties?: boolean;
+        properties: {
+            [property: string]: any;
+        };
+        type: string;
+        uischema: {
+            position: [Record<string, unknown>];
+        };
+        uiorder?: string[];
+    };
+}
+interface Hardware {
+    /** Object name */
+    name: string;
+    /** Object id */
+    id: string;
+    /** An optional object alias */
+    alias: string | null;
+    /** The object properties as defined in the relevant schema */
+    properties: {
+        [name: string]: any;
+    };
+    /** Whether the device is available */
+    online: boolean;
+    /** The object type as defined by the REST API */
+    type: string;
+    /** Any potential errors initialising this object */
+    errors?: HardwareError[];
+}
+interface HardwareChangeAction {
+    property?: string;
+    function?: string;
+    value?: any;
+}
+declare type HardwareChangeHandler = (action: HardwareChangeAction) => Promise<void> | null;
+/**
+ * Common options exposed to user as yaml configuration for hardware widgets
+ */
+interface HardwareWidgetOptions {
+    /** Whether to show the extended popup */
+    extended?: boolean;
+    /** Kind of header displayed */
+    header?: string;
+}
+declare type EditableHardware<H extends Hardware = Hardware> = H & {
+    /** Call the API to make a change on the hardware object */
+    requestChange: HardwareChangeHandler;
+};
+/**
+ * Properties which are passed to the widgets
+ */
+interface HardwareWidgetProps<H extends Hardware = Hardware, O extends HardwareWidgetOptions = HardwareWidgetOptions> {
+    /** Dynamic state of the hardware */
+    hardware: EditableHardware<H>;
+    /** Static schema describing the hardware */
+    schema: HardwareSchemaDescription;
+    /** Options passed to the widget by the yaml configuration */
+    options: O;
+    /** Add temporary message on the Daiquiri top level interface */
+    addToast: (props: {
+        type: string;
+        title: string;
+        text: string;
+    }) => void;
+    /** Global state of the widget (aggregating scan/operator/hardware states) */
+    disabled: boolean;
+    /** True if the session have the control */
+    operator: boolean;
+}
+
+type types_d_EditableHardware<H extends Hardware = Hardware> = EditableHardware<H>;
+type types_d_Hardware = Hardware;
+type types_d_HardwareChangeAction = HardwareChangeAction;
+type types_d_HardwareChangeHandler = HardwareChangeHandler;
+type types_d_HardwareSchemaDescription = HardwareSchemaDescription;
+type types_d_HardwareWidgetOptions = HardwareWidgetOptions;
+type types_d_HardwareWidgetProps<H extends Hardware = Hardware, O extends HardwareWidgetOptions = HardwareWidgetOptions> = HardwareWidgetProps<H, O>;
+declare namespace types_d {
+  export type { types_d_EditableHardware as EditableHardware, types_d_Hardware as Hardware, types_d_HardwareChangeAction as HardwareChangeAction, types_d_HardwareChangeHandler as HardwareChangeHandler, types_d_HardwareSchemaDescription as HardwareSchemaDescription, types_d_HardwareWidgetOptions as HardwareWidgetOptions, types_d_HardwareWidgetProps as HardwareWidgetProps };
+}
+
+interface GenericSchema extends Hardware {
+    properties: {
+        state: string;
+    };
+}
+interface MotorSchema extends Hardware {
+    properties: {
+        position: number;
+        target: number;
+        tolerance: number;
+        acceleration: number;
+        velocity: number;
+        limits: number[];
+        state: string[];
+        unit: string;
+        offset: number;
+        sign: number;
+    };
+}
+interface MultipositionSchema extends Hardware {
+    properties: {
+        position: string;
+        positions: {
+            position: string;
+            description: string;
+            target: {
+                axis: string;
+                destination: number;
+                tolerance: number;
+            }[];
+        }[];
+        state: string;
+    };
+}
+interface ShutterSchema extends Hardware {
+    properties: {
+        state: string;
+        status: string;
+        valid: boolean;
+        open_text: string;
+        closed_text: string;
+    };
+}
+interface FrontendSchema extends Hardware {
+    properties: {
+        state: string;
+        status: string;
+        automatic: boolean;
+        frontend: string;
+        current: number;
+        refill: number;
+        mode: string;
+        message: string;
+        feitlk: string;
+        pssitlk: string;
+        expitlk: string;
+    };
+}
+
+type schema_d_FrontendSchema = FrontendSchema;
+type schema_d_GenericSchema = GenericSchema;
+type schema_d_MotorSchema = MotorSchema;
+type schema_d_MultipositionSchema = MultipositionSchema;
+type schema_d_ShutterSchema = ShutterSchema;
+declare namespace schema_d {
+  export type { schema_d_FrontendSchema as FrontendSchema, schema_d_GenericSchema as GenericSchema, schema_d_MotorSchema as MotorSchema, schema_d_MultipositionSchema as MultipositionSchema, schema_d_ShutterSchema as ShutterSchema };
+}
+
+declare function Frontend(props: HardwareWidgetProps<FrontendSchema>): JSX.Element;
+
+interface InfoOptions extends HardwareWidgetOptions {
+    /** The property */
+    property?: string;
+    /** Unit for the property */
+    unit?: string;
+}
+declare function Info(props: HardwareWidgetProps<Hardware, InfoOptions>): JSX.Element;
+
+interface MotorDefaultOptions extends HardwareWidgetOptions {
+    /** Default step size to use for up / down arrows */
+    step?: number;
+    /** Array of selectable step sizes */
+    steps?: number[];
+    /** Number of decimals to show */
+    precision?: number;
+    /** Whether to show popup to configure extended parameters */
+    extended?: boolean;
+    /** Whether this widget is read only */
+    readOnly?: boolean;
+    /** Kind of header displayed */
+    header?: string;
+    /** Specify a fontawesome to inc the value */
+    incicon?: string;
+    /** Specify a fontawesome to dec the value */
+    decicon?: string;
+    /** If true inc and dec icon are swapped */
+    swapincdec?: boolean;
+    /** Show the step arrows horizontally instead of vertically */
+    horizontalarrows?: boolean;
+    /** Show large step arrows */
+    largearrows?: boolean;
+}
+/**
+ * The default motor widget
+ */
+declare function MotorDefault(props: HardwareWidgetProps<MotorSchema, MotorDefaultOptions>): JSX.Element;
+
+declare function Multiposition(props: HardwareWidgetProps<MultipositionSchema>): JSX.Element;
+
+interface NoObjectProps {
+    id: string;
+    name?: string;
+    options: {
+        header?: string;
+        emptyifnone?: boolean;
+    };
+}
+declare function NoObject(props: NoObjectProps): JSX.Element;
+
+interface PropertyWidgetOptions extends HardwareWidgetOptions {
+    header?: string;
+    property?: string;
+    unit?: string;
+}
+declare function Property(props: HardwareWidgetProps<GenericSchema, PropertyWidgetOptions>): JSX.Element;
+
+declare function ShutterDefault(props: HardwareWidgetProps<ShutterSchema, HardwareWidgetOptions>): JSX.Element;
+
+interface Props$3 {
+    online: boolean;
+    activeMessage?: string;
+    inactiveMessage?: string;
+    message?: string;
+    icon: string;
+    name: string;
+}
+declare function TypeIcon(props: Props$3): JSX.Element;
+
+interface Props$2 {
+    hardware: Hardware;
+    headerMode?: string;
+    widgetIcon: ReactElement;
+    widgetState: ReactElement;
+    widgetContent: ReactElement;
+}
+/**
+ * Normalized way to compose hardware component in order to provide the same
+ * kind of layout
+ */
+declare function HardwareTemplate(props: Props$2): JSX.Element;
+
+/**
+ * Input number synchronized with a hardware.
+ *
+ * Input related to hardware have specificities because the hardware state can
+ * change during the user interaction.
+ *
+ * TODO: Maybe normalize `precision` and `step` together
+ */
+declare function HardwareInputNumber(props: {
+    hardwareValue: number;
+    hardwareIsDisabled: boolean;
+    hardwareIsMoving?: boolean;
+    hardwareIsReady?: boolean;
+    onMoveRequested: (value: number) => Promise<void> | null;
+    onAbortRequested?: () => void;
+    readOnly?: boolean;
+    precision?: number;
+    step?: number;
+}): JSX.Element;
+
+/**
+ * NumericStep handled hardware properties.
+ *
+ * Input related to hardware have specificities because the hardware state can
+ * change during the user interaction.
+ */
+declare function HardwareNumericStep(props: {
+    hardwareValue: number | null;
+    hardwareIsDisabled: boolean;
+    hardwareIsMoving: boolean;
+    hardwareIsReady: boolean;
+    onMoveRequested: (value: number) => Promise<void> | null;
+    onAbortRequested: () => void;
+    /** Default step size to use for up / down arrows */
+    step?: number;
+    /** Array of selectable step sizes */
+    steps?: number[];
+    /** Number of decimals to show */
+    precision?: number;
+    /** Whether this widget is read only */
+    readOnly?: boolean;
+    /** Specify a fontawesome to inc the value */
+    incIcon?: string;
+    /** Specify a fontawesome to dec the value */
+    decIcon?: string;
+    /** If true inc and dec icon are swapped */
+    swapIncDec?: boolean;
+    /** Show the step arrows horizontally instead of vertically */
+    horizontalArrows?: boolean;
+    /** Show large step arrows */
+    largeArrows?: boolean;
+    /** Identifier passed to the input element */
+    id?: string;
+}): JSX.Element;
+
+/**
+ * Normalize the way to display an hardware state.
+ *
+ * If `minWidth` is pecified (in `em`) it ensure the widget width will stay the
+ * same when the state change
+ */
+declare function HardwareState(props: {
+    state: string;
+    variant: string;
+    minWidth?: number;
+}): JSX.Element;
+declare function MotorState(props: {
+    hardware: MotorSchema;
+}): JSX.Element;
+declare function ShutterState(props: {
+    hardware: ShutterSchema;
+    useReadyState?: boolean;
+}): JSX.Element;
+
+declare const State_d_HardwareState: typeof HardwareState;
+declare const State_d_MotorState: typeof MotorState;
+declare const State_d_ShutterState: typeof ShutterState;
+declare namespace State_d {
+  export { State_d_HardwareState as HardwareState, State_d_MotorState as MotorState, State_d_ShutterState as ShutterState };
+}
+
+declare function formatEng(scalar: number): {
+    scalar: number;
+    prefix: string;
+    multiplier: number;
+};
+/**
+ * Returns the argument as capitalized string.
+ */
+declare function ucfirst(str: string): string;
+declare function toHoursMins(seconds: number): string;
+declare function toEnergy(wavelength: number): string | 0;
+declare function round(value: number, digits: number): number;
+
+declare const formatting_d_formatEng: typeof formatEng;
+declare const formatting_d_round: typeof round;
+declare const formatting_d_toEnergy: typeof toEnergy;
+declare const formatting_d_toHoursMins: typeof toHoursMins;
+declare const formatting_d_ucfirst: typeof ucfirst;
+declare namespace formatting_d {
+  export { formatting_d_formatEng as formatEng, formatting_d_round as round, formatting_d_toEnergy as toEnergy, formatting_d_toHoursMins as toHoursMins, formatting_d_ucfirst as ucfirst };
+}
+
+interface Props$1 {
+    className?: string;
+}
+declare function FullSizer(props: PropsWithChildren<Props$1>): JSX.Element;
+
+interface Props {
+    step?: number;
+    steps?: number[];
+    disabled: boolean;
+    id?: string;
+    unit?: string;
+    overlay?: ReactChild | null;
+    incIcon?: string;
+    decIcon?: string;
+    swapIncDec?: boolean;
+    className?: string;
+    type?: 'number' | 'text';
+    precision?: number;
+    horizontalArrows?: boolean;
+    largeArrows?: boolean;
+    onBlur: () => void;
+    onChange: (e: ChangeEvent<HTMLInputElement>) => void;
+    onStep: (params: {
+        target: HTMLInputElement;
+    }) => void;
+    onKeyDown?: (e: KeyboardEvent<HTMLInputElement>) => void;
+}
+declare const NumericStep: react.ForwardRefExoticComponent<Props & react.RefAttributes<HTMLInputElement>>;
+
+export { formatting_d as Formatting, Frontend, FullSizer, HardwareInputNumber, HardwareNumericStep, schema_d as HardwareSchema, State_d as HardwareState, HardwareTemplate, types_d as HardwareTypes, Info, MotorDefault, type MotorDefaultOptions, Multiposition, NoObject, NumericStep, Property, ShutterDefault, TypeIcon };