@iotopen/react-lynx 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,439 @@
+import * as react from 'react';
+import { DependencyList, ReactNode } from 'react';
+import * as _iotopen_node_lynx from '@iotopen/node-lynx';
+import { MetaObject, WithMeta, InstallationInfo, ErrorResponse, Token, EmptyToken, Metadata, EmptyFunctionx, Functionx, OKResponse, Installation, EmptyInstallation, EmptyDevicex, Devicex, EdgeAppInstance, EdgeApp, EdgeAppVersion, EmptyOAuth2Client, OAuth2Client, Organization, MinimalOrg, Address, OrganizationChild, EmptyOrganization, EmptyUser, User, Role, EmptyNotificationMessage, NotificationMessage, EmptyNotificationOutput, NotificationOutput, NotificationOutputExecutor, LynxClient } from '@iotopen/node-lynx';
+import Paho, { Qos, TypedArray } from 'paho-mqtt';
+import { Address as Address$1 } from '@iotopen/node-lynx/src/types';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+type MetaElement = MetaObject & {
+    key: string;
+};
+declare const useMeta: (obj?: WithMeta, deps?: DependencyList) => {
+    metaList: MetaElement[];
+    compile: () => WithMeta;
+    addMeta: (e?: MetaElement) => void;
+    removeMeta: (idx: number) => void;
+    setMeta: (idx: number, e: MetaElement) => void;
+    setMetaKey: (idx: number, key: string) => void;
+    setMetaValue: (idx: number, value: string) => void;
+    setMetaProtected: (idx: number, value: boolean) => void;
+};
+
+declare const useInstallationInfo: (assignedOnly?: boolean) => {
+    installations: InstallationInfo[];
+    refresh: () => void;
+    loading: boolean;
+    error: ErrorResponse | undefined;
+};
+
+interface MQTTHandlers {
+    onMessage?: Paho.OnMessageHandler;
+    onDelivery?: Paho.OnMessageHandler;
+    onConnected?: Paho.OnConnectHandler;
+    onDisconnect?: Paho.OnConnectionLostHandler;
+}
+declare const usePahoMQTTClient: (uri: string, handlers?: MQTTHandlers, connectionOptions?: Paho.ConnectionOptions, clientId?: string) => {
+    client: react.MutableRefObject<Paho.Client>;
+    connected: boolean;
+    error: Paho.MQTTError | undefined;
+    sub: (topic: string, qos?: Qos) => Promise<Paho.Qos>;
+    pub: (topic: string, payload: string | TypedArray, qos?: Qos, retained?: boolean) => void;
+    unsub: (topic: string) => Promise<void>;
+};
+
+type Binding = (topic: string, payload: string, qos: Qos, retained: boolean) => void;
+declare const useSimpleMQTT: (uri?: string, username?: string, password?: string) => {
+    setSubs: (s: string[]) => void;
+    error: Paho.MQTTError | undefined;
+    connected: boolean;
+    bind: (topic: RegExp | string, binder: Binding) => void;
+    unbind: (binder: Binding) => void;
+    bindExact: (topic: string, binder: Binding) => void;
+    unbindExact: (topic: string, binder: Binding) => void;
+    pub: (topic: string, payload: string | Paho.TypedArray, qos?: Paho.Qos | undefined, retained?: boolean | undefined) => void;
+};
+
+declare const useTokens: () => {
+    tokens: Token[];
+    remove: (token: Token) => Promise<_iotopen_node_lynx.OKResponse>;
+    create: (token: EmptyToken) => Promise<Token>;
+    refresh: () => void;
+    loading: boolean;
+    error: ErrorResponse | undefined;
+};
+
+type FunctionTemplate = {
+    type?: string;
+    meta?: Metadata;
+    protected_meta?: Metadata;
+};
+declare const useNewFunction: (installationId: number | string, template?: FunctionTemplate) => {
+    newFunction: EmptyFunctionx;
+    setNewFunction: react.Dispatch<react.SetStateAction<EmptyFunctionx>>;
+    create: () => Promise<_iotopen_node_lynx.Functionx>;
+    setType: (t: string) => void;
+};
+
+type ObjectOrArray<X, Y, T extends Y | Y[]> = T extends Y ? Promise<X> : Promise<PromiseSettledResult<X>[]>;
+
+declare const useFunctions: (installationId: number | string, filter?: Metadata) => {
+    loading: boolean;
+    error: ErrorResponse | undefined;
+    create: <T extends EmptyFunctionx | EmptyFunctionx[]>(fns: T) => ObjectOrArray<Functionx, EmptyFunctionx, T>;
+    remove: <T_1 extends Functionx | Functionx[]>(fns: T_1) => ObjectOrArray<OKResponse, Functionx, T_1>;
+    functions: Functionx[];
+    refresh: () => void;
+};
+
+declare const useFunction: (installationId: number | string, functionId: number | string) => {
+    loading: boolean;
+    error: ErrorResponse | undefined;
+    Function: Functionx;
+    setFunction: react.Dispatch<react.SetStateAction<Functionx>>;
+    update: () => Promise<Functionx>;
+    remove: () => Promise<OKResponse>;
+    setType: (t: string) => void;
+};
+declare const useFunctionMeta: (installationId: number | string, functionId?: number | string) => {
+    createMeta: (key: string, meta: MetaObject, funId?: number, silent?: boolean) => Promise<MetaObject>;
+    updateMeta: (key: string, meta: MetaObject, createMissing?: boolean, funId?: number, silent?: boolean) => Promise<MetaObject>;
+    removeMeta: (key: string, funId?: number, silent?: boolean) => Promise<MetaObject>;
+};
+
+declare const useInstallation: (installationId: number | string) => {
+    installation: Installation;
+    setInstallation: react.Dispatch<react.SetStateAction<Installation>>;
+    update: () => Promise<Installation>;
+    remove: () => Promise<Installation>;
+    error: Error | undefined;
+    loading: boolean;
+};
+
+declare const useInstallations: (filter?: Metadata) => {
+    loading: boolean;
+    error: ErrorResponse | undefined;
+    installations: Installation[];
+    refresh: () => void;
+};
+
+type InstallationTemplate = {
+    name?: string;
+    notes?: string;
+    meta?: Metadata;
+    protected_meta?: Metadata;
+};
+declare const useNewInstallation: (organizationId: number | string, template?: InstallationTemplate) => {
+    newInstallation: EmptyInstallation;
+    setNewInstallation: react.Dispatch<react.SetStateAction<EmptyInstallation>>;
+    create: () => Promise<_iotopen_node_lynx.Installation>;
+};
+
+type DeviceTemplate = {
+    type?: string;
+    meta?: Metadata;
+    protected_meta?: Metadata;
+};
+declare const useNewDevice: (installationId: number | string, template?: DeviceTemplate) => {
+    newDevice: EmptyDevicex;
+    setNewDevice: react.Dispatch<react.SetStateAction<EmptyDevicex>>;
+    create: () => Promise<_iotopen_node_lynx.Devicex>;
+    setType: (t: string) => void;
+};
+
+declare const useDevices: (installationId: number | string, filter?: Metadata) => {
+    loading: boolean;
+    error: ErrorResponse | undefined;
+    create: <T extends EmptyDevicex | EmptyDevicex[]>(devs: T) => ObjectOrArray<Devicex, EmptyDevicex, T>;
+    remove: <T_1 extends Devicex | Devicex[]>(devs: T_1) => ObjectOrArray<OKResponse, Devicex, T_1>;
+    devices: Devicex[];
+    refresh: () => void;
+};
+
+declare const useDevice: (installationId: number | string, deviceId: number | string) => {
+    loading: boolean;
+    error: ErrorResponse | undefined;
+    Device: Devicex;
+    setDevice: react.Dispatch<react.SetStateAction<Devicex>>;
+    update: () => Promise<Devicex>;
+    remove: () => Promise<OKResponse>;
+    setType: (t: string) => void;
+};
+declare const useDeviceMeta: (installationId: number | string, deviceId?: number | string) => {
+    createMeta: (key: string, meta: MetaObject, devId?: number, silent?: boolean) => Promise<MetaObject>;
+    updateMeta: (key: string, meta: MetaObject, createMissing?: boolean, devId?: number, silent?: boolean) => Promise<MetaObject>;
+    removeMeta: (key: string, devId?: number, silent?: boolean) => Promise<MetaObject>;
+};
+
+declare const useConfiguredEdgeApps: (installationId: number | string) => {
+    refresh: () => void;
+    loading: boolean;
+    error: ErrorResponse | undefined;
+    apps: EdgeAppInstance[];
+};
+
+declare const useEdgeApps: () => {
+    apps: EdgeApp[];
+    error: ErrorResponse | undefined;
+    loading: boolean;
+    refresh: () => void;
+};
+
+declare const useEdgeApp: (appId: number | string) => {
+    loading: boolean;
+    error: ErrorResponse | undefined;
+    app: EdgeApp;
+    setApp: react.Dispatch<react.SetStateAction<EdgeApp>>;
+    refresh: () => void;
+};
+
+declare const useEdgeAppVersions: (appId: number | string, untagged?: boolean) => {
+    loading: boolean;
+    error: ErrorResponse | undefined;
+    versions: EdgeAppVersion[];
+    nameVersion: (name: string, hash: string) => Promise<EdgeAppVersion>;
+    refresh: () => void;
+};
+
+type OAuth2ClientTemplate = {
+    name?: string;
+    trusted?: boolean;
+    allowed_scopes?: string[];
+    icon_uri?: string;
+    tos_uri?: string;
+    policy_uri?: string;
+    redirect_uris?: string[];
+    id_token_alg?: string;
+};
+declare const useNewOAuth2Client: (template?: OAuth2ClientTemplate) => {
+    newClient: EmptyOAuth2Client;
+    create: () => Promise<_iotopen_node_lynx.OAuth2Client>;
+    setName: (name: string) => void;
+    setScope: (scopes: string[]) => void;
+    setIconURI: (uri: string) => void;
+    setTosURI: (uri: string) => void;
+    setPolicyURI: (uri: string) => void;
+    setRedirectURIs: (uris: string[]) => void;
+    setClient: react.Dispatch<react.SetStateAction<EmptyOAuth2Client>>;
+};
+
+declare const useOAuth2Client: (id: string) => {
+    refresh: () => void;
+    client: OAuth2Client;
+    setClient: react.Dispatch<react.SetStateAction<OAuth2Client>>;
+    error: ErrorResponse | undefined;
+    loading: boolean;
+    remove: () => Promise<_iotopen_node_lynx.OKResponse>;
+    update: () => Promise<OAuth2Client>;
+};
+
+declare const useOAuth2Clients: () => {
+    refresh: () => void;
+    clients: OAuth2Client[];
+    error: ErrorResponse | undefined;
+    loading: boolean;
+};
+
+declare const useOAuth2Consent: () => {
+    consent: (scope: string[]) => Promise<_iotopen_node_lynx.ConsentAcceptResponse>;
+    client: _iotopen_node_lynx.OAuth2Client;
+    requestedScopes: string[];
+};
+
+declare const useIDTokenAlgorithms: () => {
+    loading: boolean;
+    refresh: () => void;
+    algs: string[];
+    error: ErrorResponse | undefined;
+};
+
+declare const useOrganization: (organizationId: number | string) => {
+    loading: boolean;
+    organization: Organization;
+    setOrganization: react.Dispatch<react.SetStateAction<Organization>>;
+    error: Error | undefined;
+    update: () => Promise<Organization>;
+    remove: () => Promise<_iotopen_node_lynx.OKResponse>;
+    refresh: () => void;
+};
+
+declare const useOrganizations: <T extends boolean = false>(minimal?: T | undefined) => {
+    loading: boolean;
+    organizations: MinimalOrg<T>[];
+    setOrganizations: react.Dispatch<react.SetStateAction<MinimalOrg<T>[]>>;
+    error: ErrorResponse | undefined;
+    create: (org: Organization) => Promise<Organization>;
+    remove: (org: Organization) => Promise<_iotopen_node_lynx.OKResponse>;
+};
+
+type OrganizationTemplate = {
+    address?: Address;
+    children?: OrganizationChild[];
+    email?: string;
+    force_sms_login?: boolean;
+    phone?: string;
+    name?: string;
+    notes?: string;
+    password_valid_days?: number;
+    meta?: Metadata;
+    protected_meta?: Metadata;
+};
+declare const useNewOrganization: (parentId: number | string, template?: OrganizationTemplate) => {
+    newOrganization: EmptyOrganization;
+    setNewOrganization: react.Dispatch<react.SetStateAction<EmptyOrganization>>;
+    create: () => Promise<_iotopen_node_lynx.Organization>;
+};
+
+type UserTemplate = {
+    email?: string;
+    password?: string;
+    first_name?: string;
+    last_name?: string;
+    role?: number;
+    sms_login?: boolean;
+    mobile?: string;
+    note?: string;
+    organisations?: number[];
+    assigned_installations?: number[];
+    address?: Address$1;
+    expire_at?: number;
+    meta?: {
+        [key: string]: any;
+    };
+    protected_meta?: {
+        [key: string]: any;
+    };
+};
+declare const useNewUser: (template?: UserTemplate) => {
+    newUser: EmptyUser;
+    setNewUser: react.Dispatch<react.SetStateAction<EmptyUser>>;
+    create: () => Promise<_iotopen_node_lynx.User>;
+};
+
+declare const useUsers: (filter?: Metadata) => {
+    users: User[];
+    setUsers: react.Dispatch<react.SetStateAction<User[]>>;
+    refresh: () => void;
+    loading: boolean;
+    error: Error | undefined;
+};
+
+declare const useUser: (userId: number | string) => {
+    loading: boolean;
+    error: Error | undefined;
+    user: User;
+    setUser: react.Dispatch<react.SetStateAction<User>>;
+    update: () => Promise<User>;
+    refresh: () => void;
+    remove: () => Promise<_iotopen_node_lynx.OKResponse>;
+};
+
+declare const useRoles: () => {
+    loading: boolean;
+    error: Error | undefined;
+    roles: Role[];
+    refresh: () => void;
+};
+
+type NotificationMessageTemplate = {
+    installation_id?: number;
+    name?: string;
+    text?: string;
+};
+declare const useNewNotificationMessage: (installationId: number | string, template?: NotificationMessageTemplate) => {
+    newNotificationMessage: EmptyNotificationMessage;
+    setNewNotificationMessage: react.Dispatch<react.SetStateAction<EmptyNotificationMessage>>;
+    create: () => Promise<_iotopen_node_lynx.NotificationMessage>;
+};
+
+declare const useNotificationMessage: (installationId: number | string, notificationId: number | string) => {
+    refresh: () => void;
+    message: NotificationMessage;
+    setMessage: react.Dispatch<react.SetStateAction<NotificationMessage>>;
+    error: ErrorResponse | undefined;
+    loading: boolean;
+    remove: () => void;
+    update: () => void;
+};
+
+declare const useNotificationMessages: (installationId: number | string) => {
+    refresh: () => void;
+    notificationMessages: NotificationMessage[];
+    error: ErrorResponse | undefined;
+    loading: boolean;
+};
+
+type NotificationOutputTemplate = {
+    installation_id?: number;
+    name?: string;
+    notification_message_id?: number;
+    notification_output_executor_id?: number;
+    config?: {
+        [key: string]: string;
+    };
+};
+declare const useNewNotificationOutput: (installationId: number | string, template?: NotificationOutputTemplate) => {
+    newNotificationOutput: EmptyNotificationOutput;
+    setNewNotificationOutput: react.Dispatch<react.SetStateAction<EmptyNotificationOutput>>;
+    create: () => Promise<_iotopen_node_lynx.NotificationOutput>;
+};
+
+declare const useNotificationOutput: (installationId: number | string, notificationId: number | string) => {
+    refresh: () => void;
+    output: NotificationOutput;
+    setOutput: react.Dispatch<react.SetStateAction<NotificationOutput>>;
+    error: ErrorResponse | undefined;
+    loading: boolean;
+    remove: () => void;
+    update: () => void;
+};
+
+declare const useNotificationOutputs: (installationId: number | string) => {
+    refresh: () => void;
+    notificationOutputs: NotificationOutput[];
+    error: ErrorResponse | undefined;
+    loading: boolean;
+};
+
+declare const useNotificationOutputExecutor: (installationId: number | string, executorId: number | string) => {
+    refresh: () => void;
+    outputExecutor: NotificationOutputExecutor;
+    setOutputExecutor: react.Dispatch<react.SetStateAction<NotificationOutputExecutor>>;
+    error: ErrorResponse | undefined;
+    loading: boolean;
+};
+
+declare const useNotificationOutputExecutors: (installationId: number | string) => {
+    refresh: () => void;
+    notificationExecutors: NotificationOutputExecutor[];
+    error: ErrorResponse | undefined;
+    loading: boolean;
+};
+
+type LynxProviderProps = {
+    apiURL?: string;
+    apiKey?: string;
+    children?: ReactNode;
+};
+declare const LynxProvider: ({ children, apiURL, apiKey }: LynxProviderProps) => react_jsx_runtime.JSX.Element;
+
+interface userContext {
+    user: User | null;
+    permissions: {
+        [key: string]: boolean;
+    } | null;
+    error: ErrorResponse | undefined;
+    loading: boolean;
+}
+declare const useGlobalUser: () => userContext;
+declare const useGlobalPermissions: () => ({
+    [key: string]: boolean;
+} | null)[];
+
+interface lynxClientContext {
+    lynxClient: LynxClient;
+    newLynxClient: (url: string, apiKey?: string) => void;
+}
+declare const useGlobalLynxClient: () => lynxClientContext;
+
+export { Binding, DeviceTemplate, FunctionTemplate, InstallationTemplate, LynxProvider, MetaElement, NotificationMessageTemplate, NotificationOutputTemplate, OAuth2ClientTemplate, OrganizationTemplate, UserTemplate, useConfiguredEdgeApps, useDevice, useDeviceMeta, useDevices, useEdgeApp, useEdgeAppVersions, useEdgeApps, useFunction, useFunctionMeta, useFunctions, useGlobalLynxClient, useGlobalPermissions, useGlobalUser, useIDTokenAlgorithms, useInstallation, useInstallationInfo, useInstallations, useMeta, useNewDevice, useNewFunction, useNewInstallation, useNewNotificationMessage, useNewNotificationOutput, useNewOAuth2Client, useNewOrganization, useNewUser, useNotificationMessage, useNotificationMessages, useNotificationOutput, useNotificationOutputExecutor, useNotificationOutputExecutors, useNotificationOutputs, useOAuth2Client, useOAuth2Clients, useOAuth2Consent, useOrganization, useOrganizations, usePahoMQTTClient, useRoles, useSimpleMQTT, useTokens, useUser, useUsers };

package/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "@iotopen/react-lynx",
+    "version": "1.0.0",
+    "main": "dist/cjs/index.js",
+    "module": "dist/esm/index.js",
+    "source": "src/index.ts",
+    "scripts": {
+        "lint": "eslint --ext js,ts,tsx --max-warnings 0 src",
+        "clean": "rimraf dist",
+        "prepare": "npm run clean && npm run build:ts",
+        "dev": "npm run dev:ts",
+        "build": "npm run build:ts",
+        "build:ts": "rollup -c",
+        "dev:ts": "rollup -c -w"
+    },
+    "peerDependencies": {
+        "@iotopen/node-lynx": "^2.3.0",
+        "paho-mqtt": "^1.1.0",
+        "react": "^18.2.0",
+        "react-dom": "^18.2.0"
+    },
+    "devDependencies": {
+        "@rollup/plugin-commonjs": "^22.0.2",
+        "@rollup/plugin-node-resolve": "^14.0.1",
+        "@rollup/plugin-typescript": "^8.5.0",
+        "@types/jest": "^29.0.0",
+        "@types/node": "^18.7.16",
+        "@types/react": "^18.0.18",
+        "@types/react-dom": "^18.0.6",
+        "@typescript-eslint/eslint-plugin": "^5.36.2",
+        "@typescript-eslint/parser": "^5.36.2",
+        "cross-env": "^7.0.3",
+        "eslint": "^7.32.0",
+        "eslint-plugin-react": "^7.30.1",
+        "eslint-plugin-react-hooks": "^4.6.0",
+        "rollup": "^2.79.0",
+        "rollup-plugin-dts": "^4.2.2",
+        "rollup-plugin-peer-deps-external": "^2.2.4",
+        "rollup-plugin-terser": "^7.0.2",
+        "typescript": "^4.8.2"
+    },
+    "files": [
+        "dist"
+    ],
+    "types": "dist/index.d.ts",
+    "eslintConfig": {
+        "extends": [
+            "react-app",
+            "react-app/jest"
+        ]
+    }
+}