@dev-crew-berlin/enter-js-utils 0.5.3 → 0.5.4

package/dist/api-client/index.js

@@ -1,54 +1,3 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import APIBase from './api-base';
 import { success } from '../lib';
 import { parseAttendee, parseAttendeeList } from '../models/attendee';
@@ -59,142 +8,76 @@ import { parseInvite } from '../models/invite';
 import { parseUser } from '../models/user';
 import { parseVariable, parseVariableList } from '../models/variable';
 import { parseNoContent } from '../models/_helpers';
-var API = /** @class */ (function (_super) {
-    __extends(API, _super);
-    function API() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    API.prototype.getInstance = function (args) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.get("instances/".concat(args.instanceId), parseInstance)];
-            });
-        });
-    };
-    API.prototype.getInstanceList = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.get("instances", parseInstanceList)];
-            });
-        });
-    };
-    API.prototype.getFields = function (args) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.get("instances/".concat(args.instanceId, "/fields"), parseFieldGroups)];
-            });
-        });
-    };
-    API.prototype.getCheckinCounts = function (args) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.get("instances/".concat(args.instanceId, "/checkins"), parseCheckinCounts)];
-            });
-        });
-    };
-    API.prototype.getAttendeeList = function (args) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.get("instances/".concat(args.instanceId, "/attendees"), parseAttendeeList)];
-            });
-        });
-    };
-    API.prototype.sendEmail = function (args) {
-        return __awaiter(this, void 0, void 0, function () {
-            var guestId;
-            return __generator(this, function (_a) {
-                guestId = args.collection === 'attendees' ? args.attendeeId : args.index;
-                return [2 /*return*/, this.post("instances/".concat(args.instanceId, "/").concat(args.collection, "/").concat(guestId, "/emails/").concat(args.mailId), null, parseNoContent)];
-            });
-        });
-    };
-    API.prototype.getAttendeesByAuthCode = function (args) {
-        return __awaiter(this, void 0, void 0, function () {
-            var allAttendees;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getAttendeeList({
-                            instanceId: args.instanceId,
-                        })];
-                    case 1:
-                        allAttendees = _a.sent();
-                        if (!allAttendees.success)
-                            return [2 /*return*/, allAttendees];
-                        return [2 /*return*/, success(allAttendees.data.filter(function (attendee) { return attendee.auth === args.authCode; }))];
-                }
-            });
-        });
-    };
-    API.prototype.getInviteByAuthCode = function (args) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.get("instances/".concat(args.instanceId, "/invites/").concat(args.authCode), parseInvite)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    API.prototype.getAttendeeById = function (args) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.get("instances/".concat(args.instanceId, "/attendees/").concat(args.attendeeId), parseAttendee)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    API.prototype.createEvents = function (args) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.post("events", args.events, parseNoContent)];
-            });
-        });
-    };
-    API.prototype.getUser = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.get('user', parseUser)];
-            });
-        });
-    };
-    API.prototype.patchUser = function (args) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.patch('user', args, parseNoContent)];
-            });
-        });
-    };
-    API.prototype.getAllVariables = function (args) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.get("instances/".concat(args.instanceId, "/variables"), parseVariableList)];
-            });
-        });
-    };
-    API.prototype.getVariableByName = function (args) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.get("instances/".concat(args.instanceId, "/variables/").concat(args.variableName), parseVariable)];
-            });
-        });
-    };
-    API.prototype.createVariable = function (args) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.post("instances/".concat(args.instanceId, "/variables"), args.variable, parseVariable)];
-            });
-        });
-    };
-    API.prototype.updateVariable = function (args) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.put("instances/".concat(args.instanceId, "/variables/").concat(args.variableName), args.update, parseVariable)];
-            });
-        });
-    };
-    return API;
-}(APIBase));
-export default API;
-//# sourceMappingURL=index.js.map
+export default class API extends APIBase {
+  async getInstance(args) {
+    return this.get(`instances/${args.instanceId}`, parseInstance);
+  }
+
+  async getInstanceList() {
+    return this.get(`instances`, parseInstanceList);
+  }
+
+  async getFields(args) {
+    return this.get(`instances/${args.instanceId}/fields`, parseFieldGroups);
+  }
+
+  async getCheckinCounts(args) {
+    return this.get(`instances/${args.instanceId}/checkins`, parseCheckinCounts);
+  }
+
+  async getAttendeeList(args) {
+    return this.get(`instances/${args.instanceId}/attendees`, parseAttendeeList);
+  }
+
+  async sendEmail(args) {
+    const guestId = args.collection === 'attendees' ? args.attendeeId : args.index;
+    return this.post(`instances/${args.instanceId}/${args.collection}/${guestId}/emails/${args.mailId}`, null, parseNoContent);
+  }
+
+  async getAttendeesByAuthCode(args) {
+    // it is stupid to get all attendees here
+    // but here we would need a special endpoint that could get attendees by authcode
+    const allAttendees = await this.getAttendeeList({
+      instanceId: args.instanceId
+    });
+    if (!allAttendees.success) return allAttendees;
+    return success(allAttendees.data.filter(attendee => attendee.auth === args.authCode));
+  }
+
+  async getInviteByAuthCode(args) {
+    return await this.get(`instances/${args.instanceId}/invites/${args.authCode}`, parseInvite);
+  }
+
+  async getAttendeeById(args) {
+    return await this.get(`instances/${args.instanceId}/attendees/${args.attendeeId}`, parseAttendee);
+  }
+
+  async createEvents(args) {
+    return this.post(`events`, args.events, parseNoContent);
+  }
+
+  async getUser() {
+    return this.get('user', parseUser);
+  }
+
+  async patchUser(args) {
+    return this.patch('user', args, parseNoContent);
+  }
+
+  async getAllVariables(args) {
+    return this.get(`instances/${args.instanceId}/variables`, parseVariableList);
+  }
+
+  async getVariableByName(args) {
+    return this.get(`instances/${args.instanceId}/variables/${args.variableName}`, parseVariable);
+  }
+
+  async createVariable(args) {
+    return this.post(`instances/${args.instanceId}/variables`, args.variable, parseVariable);
+  }
+
+  async updateVariable(args) {
+    return this.put(`instances/${args.instanceId}/variables/${args.variableName}`, args.update, parseVariable);
+  }
+
+}

package/dist/lib/api-result.js

@@ -1,16 +1,12 @@
 import { isSuccess, getErrorString } from 'fefe';
 import { success, failure } from './result';
 export function apiValidator(validate) {
-    return function (value) {
-        var fefeResult = validate(value);
-        if (isSuccess(fefeResult))
-            return success(fefeResult.right);
-        return failure([
-            {
-                type: 'validation-error',
-                message: getErrorString(fefeResult.left),
-            },
-        ]);
-    };
-}
-//# sourceMappingURL=api-result.js.map
+  return value => {
+    const fefeResult = validate(value);
+    if (isSuccess(fefeResult)) return success(fefeResult.right);
+    return failure([{
+      type: 'validation-error',
+      message: getErrorString(fefeResult.left)
+    }]);
+  };
+}

package/dist/lib/class-names.js

@@ -1,13 +1,3 @@
 export function classNames(classNames) {
-    return Object.entries(classNames)
-        .filter(function (_a) {
-        var isActive = _a[1];
-        return isActive === true;
-    })
-        .map(function (_a) {
-        var className = _a[0];
-        return className;
-    })
-        .join(' ');
-}
-//# sourceMappingURL=class-names.js.map
+  return Object.entries(classNames).filter(([, isActive]) => isActive === true).map(([className]) => className).join(' ');
+}

package/dist/lib/index.js

@@ -2,5 +2,4 @@ export * from './result';
 export * as theme from './theme';
 export * from './not-undefined';
 export * from './api-result';
-export * from './class-names';
-//# sourceMappingURL=index.js.map
+export * from './class-names';

package/dist/lib/not-undefined.js

@@ -1,4 +1,3 @@
 export function notUndefined(value) {
-    return value !== undefined;
-}
-//# sourceMappingURL=not-undefined.js.map
+  return value !== undefined;
+}

package/dist/lib/result.js

@@ -1,19 +1,24 @@
 export function success(data) {
-    return { success: true, data: data };
+  return {
+    success: true,
+    data: data
+  };
 }
 export function failure(reason) {
-    return { success: false, error: reason };
+  return {
+    success: false,
+    error: reason
+  };
 }
 export function asSuccess(result) {
-    if (!result.success)
-        return undefined;
-    return result;
+  if (!result.success) return undefined;
+  return result;
 }
 export function asFailure(result) {
-    if (result.success)
-        return undefined;
-    return result;
+  if (result.success) return undefined;
+  return result;
 }
+
 /**
  * Takes a list of Results and creates one single result out of it
  *
@@ -27,20 +32,19 @@ export function asFailure(result) {
  * @returns
  */
 export function combineResults(results) {
-    if (results.every(function (result) { return result.success; })) {
-        return {
-            success: true,
-            data: results.map(
-            // the if statement checks that every result is a success so we can force this here
-            function (success) { return asSuccess(success).data; } // eslint-disable-line @typescript-eslint/no-non-null-assertion
-            ), // also the typechecker does not resolve this so we just tell him its fine and hope there are no errors
-        };
-    }
+  if (results.every(result => result.success)) {
     return {
-        success: false,
-        error: results
-            .map(function (result) { var _a; return (_a = asFailure(result)) === null || _a === void 0 ? void 0 : _a.error; })
-            .filter(function (failure) { return failure !== undefined; }), // the typechecker does not resolve this so we just tell him its fine and hope there are no errors
+      success: true,
+      data: results.map( // the if statement checks that every result is a success so we can force this here
+      success => asSuccess(success).data // eslint-disable-line @typescript-eslint/no-non-null-assertion
+      ) // also the typechecker does not resolve this so we just tell him its fine and hope there are no errors
+
     };
-}
-//# sourceMappingURL=result.js.map
+  }
+
+  return {
+    success: false,
+    error: results.map(result => asFailure(result)?.error).filter(failure => failure !== undefined) // the typechecker does not resolve this so we just tell him its fine and hope there are no errors
+
+  };
+}

package/dist/lib/theme.js

@@ -1,19 +1,18 @@
-export var colors = {
-    enterDarkGrey: '#483E47',
-    enterLightGrey: '#EEE',
-    enterMediumGrey: '#A09999',
-    enterGrey: '#D8D8D8',
-    enterBackground: '#F8FAFB',
-    enterModalBackground: '#FFFEFC',
-    enterError: '#CE1E3D',
-    enterRed: '#FF5555',
-    enterCyan: '#74ACBC',
-    enterGreen: '#89B859',
-    enterYellow: '#E7C700',
-    enterPink: '#E66084',
+export const colors = {
+  enterDarkGrey: '#483E47',
+  enterLightGrey: '#EEE',
+  enterMediumGrey: '#A09999',
+  enterGrey: '#D8D8D8',
+  enterBackground: '#F8FAFB',
+  enterModalBackground: '#FFFEFC',
+  enterError: '#CE1E3D',
+  enterRed: '#FF5555',
+  enterCyan: '#74ACBC',
+  enterGreen: '#89B859',
+  enterYellow: '#E7C700',
+  enterPink: '#E66084'
 };
-export var fonts = {
-    primary: 'PTSans, sans-serif',
-    secondary: 'Iosevka, monospace',
-};
-//# sourceMappingURL=theme.js.map
+export const fonts = {
+  primary: 'PTSans, sans-serif',
+  secondary: 'Iosevka, monospace'
+};

package/dist/models/_helpers.js

@@ -1,5 +1,6 @@
-import { branchError, failure, isFailure, leafError, number, success, } from 'fefe';
+import { branchError, failure, isFailure, leafError, number, success } from 'fefe';
 import { apiValidator } from '../lib';
+
 /**
  * creates a validator that tries to parse a unkown value to
  * a Dictionary.
@@ -12,79 +13,77 @@ import { apiValidator } from '../lib';
  * @param validator the validator for the value of the record
  */
 export function dictionary(validator) {
-    return function (value) {
-        // make shure value is an js object
-        // keep in mind lots of things in js are objects arrays, Sets…
-        // so this does not tell us too much
-        if (typeof value !== 'object' || value === null) {
-            return failure(leafError(value, 'expected value to be an object'));
-        }
-        var validatedProperties = Object.entries(value).map(function (_a) {
-            var key = _a[0], raw = _a[1];
-            // make shure the key is of type string
-            if (typeof key !== 'string') {
-                return {
-                    key: key,
-                    result: failure(leafError([key, raw], 'expected key to be of type string')),
-                };
-            }
-            // make shure the value is valid by passing it to the supplied validator
-            return { key: key, result: validator(raw) };
-        });
-        // collect possible errors
-        var errors = validatedProperties
-            .filter(function (property) { return isFailure(property.result); })
-            .map(function (property) {
-            return {
-                key: property.key,
-                error: property.result.left,
-            };
-        });
-        if (errors.length !== 0)
-            return failure(branchError(value, errors));
-        // flatten list of successfull results into single result
-        return success(validatedProperties.reduce(function (a, b) {
-            a[b.key] = b.result.right;
-            return a;
-        }, {}));
-    };
+  return value => {
+    // make shure value is an js object
+    // keep in mind lots of things in js are objects arrays, Sets…
+    // so this does not tell us too much
+    if (typeof value !== 'object' || value === null) {
+      return failure(leafError(value, 'expected value to be an object'));
+    }
+
+    const validatedProperties = Object.entries(value).map(([key, raw]) => {
+      // make shure the key is of type string
+      if (typeof key !== 'string') {
+        return {
+          key,
+          result: failure(leafError([key, raw], 'expected key to be of type string'))
+        };
+      } // make shure the value is valid by passing it to the supplied validator
+
+
+      return {
+        key,
+        result: validator(raw)
+      };
+    }); // collect possible errors
+
+    const errors = validatedProperties.filter(property => isFailure(property.result)).map(property => {
+      return {
+        key: property.key,
+        error: property.result.left
+      };
+    });
+    if (errors.length !== 0) return failure(branchError(value, errors)); // flatten list of successfull results into single result
+
+    return success(validatedProperties.reduce((a, b) => {
+      a[b.key] = b.result.right;
+      return a;
+    }, {}));
+  };
 }
 export function constant(constant) {
-    return function (value) {
-        if (value !== constant) {
-            return failure(leafError(value, "expect value to be ".concat(String(constant))));
-        }
-        return success(constant);
-    };
+  return value => {
+    if (value !== constant) {
+      return failure(leafError(value, `expect value to be ${String(constant)}`));
+    }
+
+    return success(constant);
+  };
 }
 export function toString(value) {
-    return success('' + value);
+  return success('' + value);
 }
 export function parseTimestamp(value) {
-    // js Date expects timestamp in mili seconds but we expect to parse a timestamp in seconds
-    return success(new Date(value * 1000));
+  // js Date expects timestamp in mili seconds but we expect to parse a timestamp in seconds
+  return success(new Date(value * 1000));
 }
-export function maybe(validator, defaultValue) {
-    if (defaultValue === void 0) { defaultValue = null; }
-    return function (value) {
-        if (value === null)
-            return success(defaultValue);
-        return validator(value);
-    };
+export function maybe(validator, defaultValue = null) {
+  return value => {
+    if (value === null) return success(defaultValue);
+    return validator(value);
+  };
 }
 export function noContent(value) {
-    if (value === null || value === undefined)
-        return success(null);
-    return failure(leafError(value, 'expected value to be empty'));
+  if (value === null || value === undefined) return success(null);
+  return failure(leafError(value, 'expected value to be empty'));
 }
 export function unknown() {
-    return function (value) { return success(value); };
+  return value => success(value);
 }
-export var parseNoContent = apiValidator(noContent);
-export var positiveInteger = number({
-    integer: true,
-    min: 0,
-    allowNaN: false,
-    allowInfinity: false,
-});
-//# sourceMappingURL=_helpers.js.map
+export const parseNoContent = apiValidator(noContent);
+export const positiveInteger = number({
+  integer: true,
+  min: 0,
+  allowNaN: false,
+  allowInfinity: false
+});

package/dist/models/access-token.js

@@ -1,8 +1,11 @@
 import { object, parseDate, pipe, string } from 'fefe';
 import { apiValidator } from '../lib';
-var accessToken = object({
-    accessToken: string(),
-    expires: pipe(string()).pipe(parseDate({ iso: true })),
-}, { allowExcessProperties: true });
-export var parseAccessToken = apiValidator(accessToken);
-//# sourceMappingURL=access-token.js.map
+const accessToken = object({
+  accessToken: string(),
+  expires: pipe(string()).pipe(parseDate({
+    iso: true
+  }))
+}, {
+  allowExcessProperties: true
+});
+export const parseAccessToken = apiValidator(accessToken);