@dev-crew-berlin/enter-js-utils 0.5.5 → 0.5.6

package/dist/api-client/api-base.d.ts

@@ -0,0 +1,30 @@
+import { APIResult, APIValidator } from '../lib';
+import { AccessToken } from '../models/access-token';
+export interface APICredentials {
+    accessToken: string;
+    url: string;
+}
+export default class APIBase {
+    private credentials;
+    private isLoggedIn;
+    private onLogout;
+    constructor(args: {
+        credentials: APICredentials;
+        onLogout: (reason?: string) => void;
+    });
+    private static fetchResult;
+    static fetchAccessToken(args: {
+        url: string;
+        user: string;
+        password: string;
+        deviceName: string;
+    }): Promise<APIResult<AccessToken>>;
+    static getAuthHeader(username: string, password: string): string;
+    private fetchFromEnter;
+    protected get<Model>(endpoint: string, validate: APIValidator<Model>): Promise<APIResult<Model>>;
+    protected post<Model>(endpoint: string, data: Record<string, unknown> | Array<unknown> | null, validate: APIValidator<Model>): Promise<APIResult<Model>>;
+    protected put<Model>(endpoint: string, data: Record<string, unknown> | Array<unknown>, validate: APIValidator<Model>): Promise<APIResult<Model>>;
+    protected patch<Model>(endpoint: string, data: Record<string, unknown> | Array<unknown>, validate: APIValidator<Model>): Promise<APIResult<Model>>;
+    refreshToken(): Promise<APIResult<AccessToken>>;
+    logout(): Promise<void>;
+}

package/dist/api-client/index.d.ts

@@ -0,0 +1,75 @@
+import APIBase from './api-base';
+import { APIResult } from '../lib';
+import { Attendee } from '../models/attendee';
+import { Event } from '../models';
+import { CheckinCounts } from '../models/checkin-counts';
+import { FieldGroups } from '../models/field-group';
+import { Instance } from '../models/instance';
+import { Invite } from '../models/invite';
+import { User } from '../models/user';
+import { Variable } from '../models/variable';
+import { Dictionary } from '../models/_helpers';
+export type { APICredentials } from './api-base';
+export default class API extends APIBase {
+    getInstance(args: {
+        instanceId: string;
+    }): Promise<APIResult<Instance>>;
+    getInstanceList(): Promise<APIResult<Instance[]>>;
+    getFields(args: {
+        instanceId: string;
+    }): Promise<APIResult<FieldGroups>>;
+    getCheckinCounts(args: {
+        instanceId: string;
+    }): Promise<APIResult<CheckinCounts>>;
+    getAttendeeList(args: {
+        instanceId: string;
+    }): Promise<APIResult<Attendee[]>>;
+    sendEmail(args: {
+        instanceId: string;
+        collection: 'attendees';
+        attendeeId: string;
+        mailId: string;
+    } | {
+        instanceId: string;
+        collection: 'invites';
+        index: number;
+        mailId: string;
+    }): Promise<APIResult<null>>;
+    getAttendeesByAuthCode(args: {
+        instanceId: string;
+        authCode: string;
+    }): Promise<APIResult<Attendee[]>>;
+    getInviteByAuthCode(args: {
+        instanceId: string;
+        authCode: string;
+    }): Promise<APIResult<Invite>>;
+    getAttendeeById(args: {
+        instanceId: string;
+        attendeeId: string;
+    }): Promise<APIResult<Attendee>>;
+    createEvents(args: {
+        events: Event[];
+    }): Promise<APIResult<null>>;
+    getUser(): Promise<APIResult<User>>;
+    patchUser(args: {
+        userdata: Dictionary<unknown>;
+    }): Promise<APIResult<null>>;
+    getAllVariables(args: {
+        instanceId: string;
+    }): Promise<APIResult<Variable[]>>;
+    getVariableByName(args: {
+        instanceId: string;
+        variableName: string;
+    }): Promise<APIResult<Variable>>;
+    createVariable(args: {
+        instanceId: string;
+        variable: Variable;
+    }): Promise<APIResult<Variable>>;
+    updateVariable(args: {
+        instanceId: string;
+        variableName: string;
+        update: {
+            value: string;
+        };
+    }): Promise<APIResult<Variable>>;
+}

package/dist/lib/api-result.d.ts

@@ -0,0 +1,25 @@
+import { Validator } from 'fefe';
+import { Result } from './result';
+export declare type NetworkError = {
+    type: 'network-error';
+    endpoint: string;
+    message: string;
+};
+export declare type HTTPError = {
+    type: 'http-error';
+    endpoint: string;
+    statusCode: number;
+    message?: string;
+};
+export declare type ClientError = {
+    type: 'client-error';
+    message: string;
+};
+export declare type ValidationError = {
+    type: 'validation-error';
+    message: string;
+};
+export declare type APIError = NetworkError | HTTPError | ClientError | ValidationError;
+export declare type APIResult<Model> = Result<APIError[], Model>;
+export declare type APIValidator<Model> = (value: unknown) => APIResult<Model>;
+export declare function apiValidator<T>(validate: Validator<T>): APIValidator<T>;

package/dist/lib/class-names.d.ts

@@ -0,0 +1 @@
+export declare function classNames(classNames: Record<string, boolean | undefined | null>): string;

package/dist/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from './result';
+export * as theme from './theme';
+export * from './not-undefined';
+export * from './api-result';
+export * from './class-names';

package/dist/lib/not-undefined.d.ts

@@ -0,0 +1 @@
+export declare function notUndefined<T>(value: T | undefined): value is T;

package/dist/lib/result.d.ts

@@ -0,0 +1,33 @@
+export declare type Failure<Reason> = {
+    success: false;
+    error: Reason;
+};
+export declare type Success<Payload> = {
+    success: true;
+    data: Payload;
+};
+export declare type Result<Reason, Payload> = Failure<Reason> | Success<Payload>;
+export declare function success<Payload>(data: Payload): Success<Payload>;
+export declare function failure<Reason>(reason: Reason): Failure<Reason>;
+export declare function asSuccess<Payload>(result: Result<unknown, Payload>): Success<Payload> | undefined;
+export declare function asFailure<Reason>(result: Result<Reason, unknown>): Failure<Reason> | undefined;
+declare type UnwrapSuccess<T> = T extends Success<infer Payload> ? Payload : never;
+declare type UnwrapFailure<T> = T extends Failure<infer Reason> ? Reason : never;
+declare type UnwrapArray<T> = T extends (infer R)[] ? R : never;
+declare type MergedSuccesses<T> = {
+    [K in keyof T]: UnwrapSuccess<T[K]>;
+};
+/**
+ * Takes a list of Results and creates one single result out of it
+ *
+ * If all results are successfull a Success is retured.
+ * Then the data value is an array of all the data values of the original
+ * results in correct order.
+ *
+ * If a single result has a failure a Failure is retured.
+ * The error then is an array of all the original errors.
+ * @param results
+ * @returns
+ */
+export declare function combineResults<T extends Array<Result<any, any>> | [Result<any, any>]>(results: T): Result<UnwrapFailure<UnwrapArray<T>>[], MergedSuccesses<T>>;
+export {};

package/dist/lib/theme.d.ts

@@ -0,0 +1,18 @@
+export declare const colors: {
+    enterDarkGrey: string;
+    enterLightGrey: string;
+    enterMediumGrey: string;
+    enterGrey: string;
+    enterBackground: string;
+    enterModalBackground: string;
+    enterError: string;
+    enterRed: string;
+    enterCyan: string;
+    enterGreen: string;
+    enterYellow: string;
+    enterPink: string;
+};
+export declare const fonts: {
+    primary: string;
+    secondary: string;
+};

package/dist/models/_helpers.d.ts

@@ -0,0 +1,23 @@
+import { Result, Validator } from 'fefe';
+export declare type Dictionary<T> = Record<string, T>;
+/**
+ * creates a validator that tries to parse a unkown value to
+ * a Dictionary.
+ * We define a Dictionary as a js object with strings as a key.
+ * e.g: `{ key: 'value' }
+ * The value then is whatever the validator returns
+ * So `const numDict = dictionary(number())` would make shure a object
+ * has stings as a key and numbers as values.
+ * A valid object could look like this: `{ key: 1 }`
+ * @param validator the validator for the value of the record
+ */
+export declare function dictionary<T>(validator: Validator<T>): (value: unknown) => Result<Dictionary<T>>;
+export declare function constant<T extends string | number | symbol | boolean>(constant: T): Validator<T>;
+export declare function toString(value: unknown): Result<string>;
+export declare function parseTimestamp(value: number): Result<Date>;
+export declare function maybe<T>(validator: Validator<T>): Validator<T | null>;
+export declare function maybe<T>(validator: Validator<T>, defaultValue: T): Validator<T>;
+export declare function noContent(value: unknown): Result<null>;
+export declare function unknown(): Validator<unknown>;
+export declare const parseNoContent: import("../lib").APIValidator<null>;
+export declare const positiveInteger: Validator<number, import("fefe").LeafError>;

package/dist/models/access-token.d.ts

@@ -0,0 +1,11 @@
+import { ValidatorReturnType } from 'fefe';
+declare const accessToken: import("fefe").Validator<import("fefe").ObjectResult<{
+    accessToken: import("fefe").Validator<string, import("fefe").LeafError>;
+    expires: import("fefe").Pipe<unknown, Date>;
+}>, import("fefe").FefeError>;
+export declare type AccessToken = ValidatorReturnType<typeof accessToken>;
+export declare const parseAccessToken: import("../lib").APIValidator<import("fefe").ObjectResult<{
+    accessToken: import("fefe").Validator<string, import("fefe").LeafError>;
+    expires: import("fefe").Pipe<unknown, Date>;
+}>>;
+export {};

package/dist/models/attendee.d.ts

@@ -0,0 +1,90 @@
+import { ValidatorReturnType } from 'fefe';
+import { APIResult } from '../lib';
+import { Checkin, Checkins, CheckinsJSON } from './checkins';
+import { FieldValue } from './field-value';
+export declare type AttendeeJSON = {
+    id: string;
+    auth: string | null;
+    userdata: Record<string, string>;
+    metadata: Record<string, string>;
+    tags: string[] | null;
+    language: string | null;
+    time: Date;
+    rsvp: Record<string, number | null>;
+    checkin: Record<string, CheckinsJSON>;
+    companions: {
+        isCompanion: false;
+    } | {
+        isCompanion: true;
+        mainGuestId: string;
+    };
+    payment: {
+        paid: boolean;
+        provider: 'credit' | 'paypal';
+        amount: number;
+        testmode: boolean;
+    } | null;
+};
+export declare class Attendee {
+    id: string;
+    auth: string | null;
+    userdata: Record<string, FieldValue>;
+    metadata: Record<string, string>;
+    tags: string[] | null;
+    language: string | null;
+    time: Date;
+    rsvp: Record<string, number | null>;
+    checkin: Record<string, Checkins>;
+    companions: {
+        isCompanion: false;
+    } | {
+        isCompanion: true;
+        mainGuestId: string;
+    };
+    payment: {
+        paid: boolean;
+        provider: 'credit' | 'paypal';
+        amount: number;
+        testmode: boolean;
+    } | null;
+    constructor(rawAttendee: RawAttendee);
+    getRsvpCountForTag(checkinTag: string): number;
+    getResponseForTag(checkinTag: string): 'no-response' | 'negative-repsone' | 'positive-response';
+    getCheckinsForTag(checkinTag: string): Checkins;
+    getCheckinCountForTag(checkinTag: string): number;
+    addCheckinForTag(args: {
+        checkinTag: string;
+        checkin: Checkin;
+    }): Attendee;
+    deleteCheckinForTag(args: {
+        checkinTag: string;
+        checkinId: string;
+    }): Attendee;
+}
+export declare const rawAttendee: import("fefe").Validator<import("fefe").ObjectResult<{
+    id: import("fefe").Validator<string, import("fefe").LeafError>;
+    auth: import("fefe").Validator<string | null, import("fefe").FefeError>;
+    userdata: (value: unknown) => import("fefe").Result<import("./_helpers").Dictionary<string | number | string[] | null>, import("fefe").FefeError>;
+    metadata: (value: unknown) => import("fefe").Result<import("./_helpers").Dictionary<string>, import("fefe").FefeError>;
+    tags: import("fefe").Validator<string[] | null, import("fefe").FefeError>;
+    language: import("fefe").Validator<string | null, import("fefe").FefeError>;
+    time: import("fefe").Pipe<unknown, Date>;
+    rsvp: (value: unknown) => import("fefe").Result<import("./_helpers").Dictionary<number | null>, import("fefe").FefeError>;
+    checkin: (value: unknown) => import("fefe").Result<import("./_helpers").Dictionary<Checkins>, import("fefe").FefeError>;
+    companions: import("fefe").Validator<import("fefe").ObjectResult<{
+        isCompanion: import("fefe").Validator<false, import("fefe").FefeError>;
+    }> | import("fefe").ObjectResult<{
+        isCompanion: import("fefe").Validator<true, import("fefe").FefeError>;
+        mainGuestId: import("fefe").Validator<string, import("fefe").LeafError>;
+    }>, import("fefe").LeafError>;
+    payment: import("fefe").Validator<import("fefe").ObjectResult<{
+        paid: import("fefe").Validator<boolean, import("fefe").LeafError>;
+        provider: import("fefe").Validator<"credit" | "paypal", import("fefe").LeafError>;
+        amount: import("fefe").Validator<number, import("fefe").LeafError>;
+        testmode: import("fefe").Validator<boolean, import("fefe").LeafError>;
+    }> | null, import("fefe").FefeError>;
+}>, import("fefe").FefeError>;
+declare type RawAttendee = ValidatorReturnType<typeof rawAttendee>;
+export declare const parseAttendee: (value: unknown) => APIResult<Attendee>;
+export declare const parseAttendeeList: (value: unknown) => APIResult<Attendee[]>;
+export {};

package/dist/models/checkin-counts.d.ts

@@ -0,0 +1,10 @@
+import { ValidatorReturnType } from 'fefe';
+export declare const checkinCounts: (value: unknown) => import("fefe").Result<import("./_helpers").Dictionary<import("fefe").ObjectResult<{
+    checkins: import("fefe").Validator<number, import("fefe").LeafError>;
+    rsvp: import("fefe").Validator<number, import("fefe").LeafError>;
+}>>, import("fefe").FefeError>;
+export declare type CheckinCounts = ValidatorReturnType<typeof checkinCounts>;
+export declare const parseCheckinCounts: import("../lib").APIValidator<import("./_helpers").Dictionary<import("fefe").ObjectResult<{
+    checkins: import("fefe").Validator<number, import("fefe").LeafError>;
+    rsvp: import("fefe").Validator<number, import("fefe").LeafError>;
+}>>>;

package/dist/models/checkins.d.ts

@@ -0,0 +1,40 @@
+import { Result as FefeResult, ValidatorReturnType } from 'fefe';
+export declare type Checkin = {
+    id: string;
+    time: Date;
+    main: boolean;
+};
+export declare type CheckinsJSON = {
+    checkins: {
+        id: string;
+        time: string;
+        main: boolean;
+    }[];
+    deleted: string[];
+};
+export declare class Checkins {
+    checkins: Checkin[];
+    deleted: string[];
+    constructor(rawCheckins: RawCheckins);
+    toJSON(): CheckinsJSON;
+    getAllCheckins(): Checkin[];
+    getOtherCheckins(): Checkin[];
+    getMainCheckin(): Checkin | undefined;
+    merge(otherCheckin: Checkins): Checkins;
+}
+export declare const checkin: import("fefe").Validator<import("fefe").ObjectResult<{
+    id: import("fefe").Validator<string, import("fefe").LeafError>;
+    time: import("fefe").Pipe<unknown, Date>;
+    main: import("fefe").Validator<boolean, import("fefe").LeafError>;
+}>, import("fefe").FefeError>;
+declare const rawCheckins: import("fefe").Validator<import("fefe").ObjectResult<{
+    checkins: import("fefe").Validator<import("fefe").ObjectResult<{
+        id: import("fefe").Validator<string, import("fefe").LeafError>;
+        time: import("fefe").Pipe<unknown, Date>;
+        main: import("fefe").Validator<boolean, import("fefe").LeafError>;
+    }>[], import("fefe").FefeError>;
+    deleted: import("fefe").Validator<string[], import("fefe").FefeError>;
+}>, import("fefe").FefeError>;
+declare type RawCheckins = ValidatorReturnType<typeof rawCheckins>;
+export declare const checkins: (value: unknown) => FefeResult<Checkins>;
+export {};

package/dist/models/event.d.ts

@@ -0,0 +1,40 @@
+import { Attendee } from './attendee';
+import { Checkin } from './checkins';
+export declare type Event = {
+    id: string;
+    event: 'checkin-created';
+    instanceName: string;
+    attendeeId: string;
+    checkinTag: string;
+    checkin: Checkin;
+} | {
+    id: string;
+    event: 'checkin-deleted';
+    instanceName: string;
+    attendeeId: string;
+    checkinTag: string;
+    checkinId: string;
+} | {
+    id: string;
+    event: 'attendee-created';
+    instanceName: string;
+    attendee: Attendee;
+} | {
+    id: string;
+    event: 'attendee-updated';
+    instanceName: string;
+    attendeeId: string;
+    updates: Partial<Omit<Attendee, 'id' | 'checkin'>>;
+} | {
+    id: string;
+    event: 'attendee-responded';
+    instanceName: string;
+    attendeeId: string;
+    rsvp: Record<string, number | null>;
+    isEdit?: boolean;
+} | {
+    id: string;
+    event: 'payment-paid';
+    instanceName: string;
+    attendeeId: string;
+};