@photonhealth/elements 0.0.93 → 0.0.95

package/dist/store.d.ts

@@ -0,0 +1,99 @@
+import { PhotonClient } from '@photonhealth/sdk';
+import { Catalog, DispenseUnit, MutationCreatePrescriptionArgs, Patient, Prescription, PrescriptionTemplate, Treatment } from '@photonhealth/sdk/dist/types';
+import { GraphQLError } from 'graphql';
+import { Permission } from '../types';
+export declare class PhotonClientStore {
+    private sdk;
+    private setStore;
+    private store;
+    authentication: {
+        state: {
+            user: any;
+            isAuthenticated: boolean;
+            isInOrg: boolean;
+            permissions: Permission[];
+            error?: string;
+            isLoading: boolean;
+        };
+        handleRedirect: (url?: string) => Promise<void>;
+        checkSession: () => Promise<void>;
+        login: (args?: object) => Promise<void>;
+        logout: () => void;
+    };
+    getSDK: () => PhotonClient;
+    clinical: {
+        catalog: {
+            state: {
+                isLoading: boolean;
+                treatments: Treatment[];
+                templates: PrescriptionTemplate[];
+            };
+            getCatalog: (args: {
+                id: string;
+            }) => void;
+        };
+        catalogs: {
+            state: {
+                isLoading: boolean;
+                catalogs: Catalog[];
+            };
+            getCatalogs: () => void;
+        };
+        dispenseUnits: {
+            state: {
+                isLoading: boolean;
+                dispenseUnits: Array<DispenseUnit & {
+                    id: string;
+                }>;
+            };
+            getDispenseUnits: () => void;
+        };
+        patients: {
+            state: {
+                isLoading: boolean;
+                patients: Patient[];
+                finished: boolean;
+            };
+            getPatients: (args?: {
+                after?: string;
+                first?: number;
+                name?: string;
+                clear?: boolean;
+            }) => void;
+        };
+        patient: {
+            state: {
+                isLoading: boolean;
+                patient?: Patient;
+            };
+            getPatient: (args: {
+                id: string;
+            }) => Promise<Patient>;
+        };
+        prescription: {
+            state: {
+                isLoading: boolean;
+                data?: Prescription;
+                errors: GraphQLError[];
+                error?: any;
+            };
+            createPrescription: (args: MutationCreatePrescriptionArgs) => Promise<{
+                data: {
+                    createPrescription: Prescription;
+                } | null | undefined;
+                errors: readonly GraphQLError[] | undefined;
+            }>;
+        };
+    };
+    constructor(sdk: PhotonClient);
+    private _getSDK;
+    private checkSession;
+    private login;
+    private logout;
+    private getPatients;
+    private getPatient;
+    private getCatalog;
+    private getCatalogs;
+    private getDispenseUnits;
+    private createPrescription;
+}

package/dist/stores/catalog.d.ts

@@ -1,12 +1,15 @@
+import { PhotonClient } from '@photonhealth/sdk';
+import { Catalog } from '@photonhealth/sdk/dist/types';
+import { GraphQLError } from 'graphql';
 export declare const CatalogStore: {
     store: {
         catalogs: {
-            data: import("@photonhealth/sdk/dist/types").Catalog[];
-            errors: readonly import("graphql").GraphQLError[];
+            data: Catalog[];
+            errors: readonly GraphQLError[];
             isLoading: boolean;
         };
     };
     actions: {
-        getCatalogs: (client: import("@photonhealth/sdk").PhotonClient) => Promise<void>;
+        getCatalogs: (client: PhotonClient) => Promise<void>;
     };
 };

package/dist/stores/dispenseUnit.d.ts

@@ -1,12 +1,18 @@
+import { PhotonClient } from '@photonhealth/sdk';
+import { GraphQLError } from 'graphql';
+import { DispenseUnit } from '@photonhealth/sdk/dist/types';
+export type StoreDispenseUnit = {
+    id: string;
+} & DispenseUnit;
 export declare const DispenseUnitStore: {
     store: {
         dispenseUnits: {
-            data: import("@photonhealth/components/dist/src/stores/dispenseUnit").StoreDispenseUnit[];
-            errors: readonly import("graphql").GraphQLError[];
+            data: StoreDispenseUnit[];
+            errors: readonly GraphQLError[];
             isLoading: boolean;
         };
     };
     actions: {
-        getDispenseUnits: (client: import("@photonhealth/sdk").PhotonClient) => Promise<void>;
+        getDispenseUnits: (client: PhotonClient) => Promise<void>;
     };
 };

package/dist/stores/form.d.ts

@@ -1,2 +1,22 @@
-import { createFormStore } from '@photonhealth/components';
-export { createFormStore };
+import { Struct } from 'superstruct';
+export declare const createFormStore: (initalValue?: Record<string, any>) => {
+    store: Record<string, {
+        value: any;
+        error?: string | undefined;
+    } | undefined>;
+    actions: {
+        updateFormValue: ({ key, value }: {
+            key: string;
+            value: any;
+        }) => void;
+        clearKeys: (keys: string[]) => void;
+        registerValidator: ({ key, validator }: {
+            key: string;
+            validator: Struct<any, any>;
+        }) => void;
+        unRegisterValidator: (key: string) => void;
+        validate: (keys?: string[]) => void;
+        hasErrors: (keys: string[]) => boolean;
+        reset: () => void;
+    };
+};

package/dist/stores/patient.d.ts

@@ -1,23 +1,26 @@
+import { PhotonClient } from '@photonhealth/sdk';
+import { Patient } from '@photonhealth/sdk/dist/types';
+import { GraphQLError } from 'graphql';
 export declare const PatientStore: {
     store: {
         patients: {
-            data: import("@photonhealth/sdk/dist/types").Patient[];
-            errors: readonly import("graphql").GraphQLError[];
+            data: Patient[];
+            errors: readonly GraphQLError[];
             isLoading: boolean;
             finished: boolean;
         };
         selectedPatient: {
-            data?: import("@photonhealth/sdk/dist/types").Patient | undefined;
-            errors: readonly import("graphql").GraphQLError[];
+            data?: Patient;
+            errors: readonly GraphQLError[];
             isLoading: boolean;
         };
     };
     actions: {
-        getPatients: (client: import("@photonhealth/sdk").PhotonClient, args?: {
-            first?: number | undefined;
-            name?: string | undefined;
-        } | undefined) => Promise<(() => Promise<(() => Promise<any>) | undefined>) | undefined>;
-        getSelectedPatient: (client: import("@photonhealth/sdk").PhotonClient, id: string) => Promise<void>;
+        getPatients: (client: PhotonClient, args?: {
+            first?: number;
+            name?: string;
+        }) => Promise<(() => Promise<(() => Promise<any | undefined>) | undefined>) | undefined>;
+        getSelectedPatient: (client: PhotonClient, id: string) => Promise<void>;
         clearSelectedPatient: () => Promise<void>;
         reset: () => Promise<void>;
     };

package/dist/stores/pharmacy.d.ts

@@ -1,37 +1,40 @@
 /// <reference types="@types/google.maps" />
+import { PhotonClient } from '@photonhealth/sdk';
+import { Pharmacy } from '@photonhealth/sdk/dist/types';
+import { GraphQLError } from 'graphql';
 export declare const PharmacyStore: {
     store: {
         pharmacies: {
-            data: import("@photonhealth/sdk/dist/types").Pharmacy[];
-            address?: string | undefined;
-            errors: readonly (import("graphql").GraphQLError | Error)[];
+            data: Pharmacy[];
+            address?: string;
+            errors: readonly (GraphQLError | Error)[];
             isLoading: boolean;
         };
         selectedPharmacy: {
-            data?: import("@photonhealth/sdk/dist/types").Pharmacy | undefined;
-            errors: readonly import("graphql").GraphQLError[];
+            data?: Pharmacy;
+            errors: readonly GraphQLError[];
             isLoading: boolean;
         };
         preferredPharmacies: {
-            data?: import("@photonhealth/sdk/dist/types").Pharmacy[] | undefined;
-            errors: readonly import("graphql").GraphQLError[];
+            data?: Pharmacy[];
+            errors: readonly GraphQLError[];
             isLoading: boolean;
         };
     };
     actions: {
-        getPharmacies: (client: import("@photonhealth/sdk").PhotonClient, args: {
-            name?: string | undefined;
+        getPharmacies: (client: PhotonClient, args: {
+            name?: string;
             location: {
                 latitude: number;
                 longitude: number;
                 radius: number;
             };
-            first?: number | undefined;
+            first?: number;
         }) => Promise<void>;
-        getPharmaciesByAddress: (client: import("@photonhealth/sdk").PhotonClient, geocoder: google.maps.Geocoder, address: string, name?: string | undefined) => Promise<void>;
-        getPharmacy: (client: import("@photonhealth/sdk").PhotonClient, id: string) => Promise<void>;
+        getPharmaciesByAddress: (client: PhotonClient, geocoder: google.maps.Geocoder, address: string, name?: string) => Promise<void>;
+        getPharmacy: (client: PhotonClient, id: string) => Promise<void>;
         clearSelectedPharmacy: () => void;
-        getPreferredPharmacies: (client: import("@photonhealth/sdk").PhotonClient, id: string) => Promise<void>;
+        getPreferredPharmacies: (client: PhotonClient, id: string) => Promise<void>;
         clearPreferredPharmacies: () => void;
         reset: () => Promise<void>;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@photonhealth/elements",
-  "version": "0.0.93",
+  "version": "0.0.95",
   "description": "",
   "main": "dist/index.js",
   "types": "./dist/index.d.ts",