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

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 /// <reference types="react" />
+import * as react from 'react';
+import { ReactElement, PropsWithChildren, ReactChild, ChangeEvent, KeyboardEvent } from 'react';
+
 interface HardwareError {
     property: string;
     exception: string;
@@ -87,6 +90,22 @@ interface HardwareWidgetProps<H extends Hardware = Hardware, O extends HardwareW
     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;
@@ -101,6 +120,64 @@ interface MotorSchema extends Hardware {
         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 */
@@ -131,4 +208,180 @@ interface MotorDefaultOptions extends HardwareWidgetOptions {
  */
 declare function MotorDefault(props: HardwareWidgetProps<MotorSchema, MotorDefaultOptions>): JSX.Element;
 
-export { MotorDefault };
+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 };