@sitecore/sc-contenthub-webclient-sdk 0.9.7

package/dist/link-helper.js

@@ -0,0 +1,371 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkHelper = void 0;
+const URITemplate_1 = __importDefault(require("urijs/src/URITemplate"));
+const constants_1 = require("./constants");
+const api_1 = require("./constants/api");
+const argument_error_1 = require("./errors/argument-error");
+const guard_1 = __importDefault(require("./guard"));
+const link_1 = __importDefault(require("./link"));
+const type_guards_1 = require("./type-guards");
+class LinkHelper {
+    constructor(client) {
+        guard_1.default.notNullOrUndefined(client);
+        this._client = client;
+    }
+    //#region Datasources
+    nameFromDataSourceAsync(link) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (link == null)
+                return null;
+            const variable = yield this.getVariableValueAsync(link, api_1.DATA_SOURCE_BY_NAME.templateName, api_1.DATA_SOURCE_BY_NAME.name);
+            return variable || null;
+        });
+    }
+    dataSourceToLinkAsync(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(name);
+            return this.bindAsync(api_1.DATA_SOURCE_BY_NAME.templateName, { [api_1.DATA_SOURCE_BY_NAME.name]: name });
+        });
+    }
+    dataSourcesLinkAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const routes = yield this._client.api.getApiRoutesAsync();
+            return routes[api_1.DATA_SOURCES.templateName];
+        });
+    }
+    //#endregion
+    //#region Definitions
+    nameFromDefinitionAsync(link) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!link)
+                return null;
+            const variable = yield this.getVariableValueAsync(link, api_1.ENTITY_DEFINITION_BY_NAME.templateName, api_1.ENTITY_DEFINITION_BY_NAME.name);
+            return variable || null;
+        });
+    }
+    namesFromDefinitionsAsync(links) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!links)
+                return [];
+            const result = [];
+            links.forEach((link) => __awaiter(this, void 0, void 0, function* () {
+                result.push(yield this.nameFromDefinitionAsync(link));
+            }));
+            return result;
+        });
+    }
+    definitionToLinkAsync(param, includeConditionalMembers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(param);
+            if (typeof param === "string") {
+                guard_1.default.stringNotNullOrEmpty(param);
+                const variables = {
+                    [api_1.ENTITY_DEFINITION_BY_NAME.name]: param,
+                };
+                if (includeConditionalMembers != null) {
+                    variables[api_1.ENTITY_DEFINITION_BY_NAME.includeConditionalMembers] = includeConditionalMembers.toString();
+                }
+                return this.bindAsync(api_1.ENTITY_DEFINITION_BY_NAME.templateName, variables);
+            }
+            else {
+                guard_1.default.validId(param);
+                const variables = {
+                    [api_1.ENTITY_DEFINITION_BY_ID.id]: param.toString(),
+                };
+                if (includeConditionalMembers != null) {
+                    variables[api_1.ENTITY_DEFINITION_BY_ID.includeConditionalMembers] = includeConditionalMembers.toString();
+                }
+                return this.bindAsync(api_1.ENTITY_DEFINITION_BY_ID.templateName, variables);
+            }
+        });
+    }
+    definitionToLinkV2Async(name, includeConditionalMembers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(name);
+            const variables = {
+                [api_1.ENTITY_DEFINITION_BY_NAME_V2.name]: name,
+            };
+            if (includeConditionalMembers != null) {
+                variables[api_1.ENTITY_DEFINITION_BY_NAME_V2.includeConditionalMembers] = includeConditionalMembers.toString();
+            }
+            return this.bindAsync(api_1.ENTITY_DEFINITION_BY_NAME_V2.templateName, variables);
+        });
+    }
+    definitionsToLinkAsync(values, skip, take, includeConditionalMembers, viewMode) {
+        return __awaiter(this, arguments, void 0, function* () {
+            const variables = LinkHelper.applyEntityDefinitionVariables(skip, take, includeConditionalMembers, viewMode);
+            if (values == null && arguments.length === 1) {
+                throw new argument_error_1.ArgumentError("Missing function arguments.");
+            }
+            if (values) {
+                guard_1.default.arrayNotEmpty(values);
+                if (type_guards_1.TypeGuards.isStringArray(values)) {
+                    variables[api_1.ENTITY_DEFINITIONS.definitionsToLoadByName] = values.join();
+                }
+                else {
+                    variables[api_1.ENTITY_DEFINITIONS.definitionsToLoadById] = values.join();
+                }
+            }
+            return this.bindAsync(api_1.ENTITY_DEFINITIONS.templateName, variables);
+        });
+    }
+    definitionsLinkAsync(skip, take, includeConditionalMembers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const variables = LinkHelper.applyEntityDefinitionVariables(skip, take, includeConditionalMembers);
+            return this.bindAsync(api_1.ENTITY_DEFINITIONS.templateName, variables);
+        });
+    }
+    //#endregion
+    //#region Entities
+    idFromEntityAsync(link) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!link)
+                return null;
+            const variable = yield this.getVariableValueAsync(link, api_1.ENTITY_BY_ID.templateName, api_1.ENTITY_BY_ID.id);
+            if (!variable)
+                return null;
+            guard_1.default.parsableInteger(variable);
+            return parseInt(variable);
+        });
+    }
+    idsFromEntitiesAsync(links) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!links || links.length === 0)
+                return [];
+            const list = [];
+            for (const link of links) {
+                const id = yield this.idFromEntityAsync(link);
+                if (id != null && id !== 0) {
+                    list.push(id);
+                }
+            }
+            return list;
+        });
+    }
+    entityToLinkAsync(param, culture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(param);
+            if (typeof param === "string") {
+                guard_1.default.stringNotNullOrEmpty(param);
+                return this.bindAsync(api_1.ENTITY_BY_IDENTIFIER.templateName, {
+                    [api_1.ENTITY_BY_IDENTIFIER.identifier]: param,
+                });
+            }
+            else {
+                guard_1.default.validId(param);
+                const variables = {
+                    [api_1.ENTITY_BY_ID.id]: param.toString(),
+                };
+                if (culture != null) {
+                    variables[api_1.ENTITY_BY_ID.culture] = culture;
+                }
+                return this.bindAsync(api_1.ENTITY_BY_ID.templateName, variables);
+            }
+        });
+    }
+    entitiesToLinksAsync(ids) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ids || ids.length === 0)
+                return [];
+            guard_1.default.validIds(ids);
+            const list = [];
+            for (const id of ids) {
+                const link = yield this.entityToLinkAsync(id);
+                if (link) {
+                    list.push(link);
+                }
+            }
+            return list;
+        });
+    }
+    identifierFromEntityAsync(link) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!link)
+                return null;
+            return this.getVariableValueAsync(link, api_1.ENTITY_BY_IDENTIFIER.templateName, api_1.ENTITY_BY_IDENTIFIER.identifier);
+        });
+    }
+    entitiesLinkAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const routes = yield this._client.api.getApiRoutesAsync();
+            return routes[api_1.ENTITIES.templateName];
+        });
+    }
+    permissionsForEntityToLinkAsync(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.validId(id);
+            return this.bindAsync(api_1.PERMISSIONS_FOR_ENTITY.templateName, api_1.PERMISSIONS_FOR_ENTITY.id, id.toString());
+        });
+    }
+    //#endregion
+    //#region Passwords
+    setUserPasswordToLinkAsync(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.validId(userId);
+            return this.bindAsync(api_1.SET_USER_PASSWORD.templateName, api_1.SET_USER_PASSWORD.userId, userId.toString());
+        });
+    }
+    resetPasswordToLinkAsync(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.validId(userId);
+            return this.bindAsync(api_1.RESET_PASSWORD.templateName, api_1.RESET_PASSWORD.userId, userId.toString());
+        });
+    }
+    //#endregion
+    //#region Policy
+    policyToLinkAsync(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.validId(id);
+            return this.bindAsync(constants_1.API.POLICY_BY_ID.templateName, constants_1.API.POLICY_BY_ID.id, id.toString());
+        });
+    }
+    idFromPolicyAsync(link) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (link == null) {
+                return null;
+            }
+            const variable = yield this.getVariableValueAsync(link, constants_1.API.POLICY_BY_ID.templateName, constants_1.API.POLICY_BY_ID.id);
+            guard_1.default.parsableInteger(variable);
+            return parseInt(variable);
+        });
+    }
+    //#endregion
+    //#region Commands
+    commandToLinkAsync(namespace, command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(namespace);
+            guard_1.default.stringNotNullOrEmpty(command);
+            const variables = {
+                [constants_1.API.COMMANDS.folder]: namespace,
+                [constants_1.API.COMMANDS.command]: command,
+            };
+            const res = yield this.bindAsync(constants_1.API.COMMANDS.templateName, variables);
+            return res;
+        });
+    }
+    //#endregion
+    //#region Mails
+    sendConfirmationMailToLinkAsync(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.validId(userId);
+            return this.bindAsync(api_1.SEND_CONFIRMATION_MAIL.templateName, api_1.SEND_CONFIRMATION_MAIL.userId, userId.toString());
+        });
+    }
+    sendNotificationToLinkAsync(notificationType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(notificationType);
+            const task = this.bindAsync(api_1.SEND_NOTIFICATION.templateName, api_1.SEND_NOTIFICATION.type, notificationType);
+            return task;
+        });
+    }
+    //#endregion
+    //#region Aggregates
+    aggregateToLinkAsync(aggregateName, entityId, culture, loadPermissions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(aggregateName);
+            guard_1.default.validId(entityId);
+            const variables = {
+                [constants_1.API.AGGREGATES.name]: aggregateName,
+                [constants_1.API.AGGREGATES.id]: entityId.toString(),
+            };
+            if (culture) {
+                variables[constants_1.API.AGGREGATES.culture] = culture;
+            }
+            if (loadPermissions != undefined) {
+                variables[constants_1.API.AGGREGATES.loadPermissions] = loadPermissions.toString();
+            }
+            const aggregateLink = this.bindAsync(api_1.AGGREGATES.templateName, variables);
+            return aggregateLink;
+        });
+    }
+    //#endregion
+    //#region PageResource
+    pageResourceToLinkAsync(page, culture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(culture);
+            guard_1.default.notNullOrUndefined(page);
+            const variables = { [constants_1.API.PAGE_BY_IDENTIFIER.culture]: culture };
+            let templateName = "";
+            if (typeof page === "string") {
+                guard_1.default.stringNotNullOrEmpty(page);
+                variables[constants_1.API.PAGE_BY_IDENTIFIER.identifier] = page;
+                templateName = constants_1.API.PAGE_BY_IDENTIFIER.templateName;
+            }
+            else {
+                guard_1.default.validId(page);
+                variables[constants_1.API.PAGE_BY_ID.id] = page.toString();
+                templateName = constants_1.API.PAGE_BY_ID.templateName;
+            }
+            const pageLink = this.bindAsync(templateName, variables);
+            return pageLink;
+        });
+    }
+    //#endregion
+    //#region Search
+    searchLinkAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const routes = yield this._client.api.getApiRoutesAsync();
+            return routes[api_1.SEARCH.templateName];
+        });
+    }
+    //#endregion
+    getVariableValueAsync(link, templateName, variable) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const routes = yield this._client.api.getApiRoutesAsync();
+            const value = link.getVariableValue(routes[templateName], variable);
+            return value;
+        });
+    }
+    bindAsync(templateName, value, argument) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let values = {};
+            if (typeof value === "string") {
+                guard_1.default.stringNotNullOrEmpty(value);
+                guard_1.default.notNullOrUndefined(argument);
+                values[value] = argument;
+            }
+            else {
+                values = value;
+            }
+            const routes = yield this._client.api.getApiRoutesAsync();
+            const link = routes[templateName];
+            if (!link.templated) {
+                return new link_1.default(link.href);
+            }
+            else {
+                const template = new URITemplate_1.default(link.href);
+                return new link_1.default(template.expand(values));
+            }
+        });
+    }
+    static applyEntityDefinitionVariables(skip, take, includeConditionalMembers, viewMode) {
+        const variables = {};
+        if (skip != null && skip !== 0) {
+            variables[api_1.ENTITY_DEFINITIONS.skip] = skip.toString();
+        }
+        if (take != null) {
+            variables[api_1.ENTITY_DEFINITIONS.take] = take.toString();
+        }
+        if (includeConditionalMembers != null) {
+            variables[api_1.ENTITY_DEFINITIONS.includeConditionalMembers] = includeConditionalMembers.toString();
+        }
+        if (viewMode != null) {
+            variables[api_1.ENTITY_DEFINITIONS.viewMode] = viewMode;
+        }
+        return variables;
+    }
+}
+exports.LinkHelper = LinkHelper;

package/dist/link.d.ts

@@ -0,0 +1,9 @@
+import URI = require("urijs");
+export default class Link {
+    href: string;
+    title: string;
+    templated: boolean;
+    constructor(uri: string | URI, title?: string, templated?: boolean);
+    getVariableValue(template: Link, variable: string): string;
+    static copyFrom(source: Link): Link;
+}

package/dist/link.js

@@ -0,0 +1,78 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var Link_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+const URI = require("urijs");
+const ta_json_1 = require("ta-json");
+const guard_1 = __importDefault(require("./guard"));
+let Link = Link_1 = class Link {
+    constructor(uri, title, templated) {
+        this.templated = false;
+        if (typeof uri === "string") {
+            this.href = uri;
+        }
+        else {
+            this.href = uri.href();
+        }
+        if (title) {
+            this.title = title;
+        }
+        this.templated = !!templated;
+    }
+    getVariableValue(template, variable) {
+        guard_1.default.notNullOrUndefined(template);
+        guard_1.default.stringNotNullOrEmpty(variable);
+        guard_1.default.stringNotNullOrEmpty(this.href);
+        const templateUri = new URI(template.href);
+        const currentUri = new URI(this.href);
+        const index = templateUri
+            .path()
+            .split("/")
+            .findIndex(item => item.startsWith(`{${variable}}`));
+        if (index) {
+            return decodeURIComponent(currentUri.path().split("/")[index]);
+        }
+        let queryRegexStr = `\?|,${variable.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&")},|$`;
+        let queryRegex = new RegExp(queryRegexStr);
+        if (queryRegex.test(templateUri.query())) {
+            queryRegexStr = `(?:^|&)${variable.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&")}=([^#&]+)(?:[#&]?|$)`;
+            queryRegex = new RegExp(queryRegexStr);
+            const matches = queryRegex.exec(currentUri.query());
+            if (matches) {
+                return decodeURIComponent(matches[1]);
+            }
+        }
+        throw `Variable '${variable}' not found in template '${template.href}'.`;
+    }
+    static copyFrom(source) {
+        return new Link_1(source.href, source.title, source.templated);
+    }
+};
+__decorate([
+    ta_json_1.JsonProperty("href"),
+    __metadata("design:type", String)
+], Link.prototype, "href", void 0);
+__decorate([
+    ta_json_1.JsonProperty("title"),
+    __metadata("design:type", String)
+], Link.prototype, "title", void 0);
+__decorate([
+    ta_json_1.JsonProperty("templated"),
+    __metadata("design:type", Boolean)
+], Link.prototype, "templated", void 0);
+Link = Link_1 = __decorate([
+    ta_json_1.JsonObject(),
+    __metadata("design:paramtypes", [Object, String, Boolean])
+], Link);
+exports.default = Link;

package/dist/logging/log-level.d.ts

@@ -0,0 +1,6 @@
+export declare enum LogLevel {
+    Debug = 0,
+    Info = 1,
+    Warn = 2,
+    Error = 3
+}

package/dist/logging/log-level.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["Debug"] = 0] = "Debug";
+    LogLevel[LogLevel["Info"] = 1] = "Info";
+    LogLevel[LogLevel["Warn"] = 2] = "Warn";
+    LogLevel[LogLevel["Error"] = 3] = "Error";
+})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));

package/dist/logging/logger-base.d.ts

@@ -0,0 +1,26 @@
+import { LogLevel } from "./log-level";
+import { ILogger } from "./logger";
+export default abstract class LoggerBase implements ILogger {
+    minimumLogLevel: LogLevel;
+    get isDebugEnabled(): boolean;
+    get isInfoEnabled(): boolean;
+    get isWarnEnabled(): boolean;
+    get isErrorEnabled(): boolean;
+    debug(message: (() => string) | string): void;
+    debugAsync(message: () => Promise<string>): Promise<void>;
+    info(message: (() => string) | string): void;
+    infoAsync(message: () => Promise<string>): Promise<void>;
+    warn(message: (() => string) | string): void;
+    warnAsync(message: () => Promise<string>): Promise<void>;
+    error(message: (() => string) | string, error?: Error): void;
+    errorAsync(message: () => Promise<string>, error?: Error): Promise<void>;
+    abstract logDebug(message: string): void;
+    abstract logInfo(message: string): void;
+    abstract logWarn(message: string): void;
+    abstract logError(message: string, error?: Error): void;
+    abstract logError(error: Error): void;
+    private handleDebugMessage;
+    private handleInfoMessage;
+    private handleWarnMessage;
+    private handleErrorMessage;
+}

package/dist/logging/logger-base.js

@@ -0,0 +1,98 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_level_1 = require("./log-level");
+class LoggerBase {
+    constructor() {
+        this.minimumLogLevel = log_level_1.LogLevel.Info;
+    }
+    get isDebugEnabled() {
+        return this.minimumLogLevel <= log_level_1.LogLevel.Debug;
+    }
+    get isInfoEnabled() {
+        return this.minimumLogLevel <= log_level_1.LogLevel.Info;
+    }
+    get isWarnEnabled() {
+        return this.minimumLogLevel <= log_level_1.LogLevel.Warn;
+    }
+    get isErrorEnabled() {
+        return this.minimumLogLevel <= log_level_1.LogLevel.Error;
+    }
+    debug(message) {
+        if (this.isDebugEnabled) {
+            this.handleDebugMessage(typeof message === "function" ? message() : message);
+        }
+    }
+    debugAsync(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isDebugEnabled) {
+                const msg = yield message();
+                this.handleDebugMessage(msg);
+            }
+        });
+    }
+    info(message) {
+        if (this.isInfoEnabled) {
+            this.handleInfoMessage(typeof message === "function" ? message() : message);
+        }
+    }
+    infoAsync(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isInfoEnabled) {
+                const msg = yield message();
+                this.handleInfoMessage(msg);
+            }
+        });
+    }
+    warn(message) {
+        if (this.isWarnEnabled) {
+            this.handleWarnMessage(typeof message === "function" ? message() : message);
+        }
+    }
+    warnAsync(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isWarnEnabled) {
+                const msg = yield message();
+                this.handleWarnMessage(msg);
+            }
+        });
+    }
+    error(message, error) {
+        if (this.isErrorEnabled) {
+            this.handleErrorMessage(typeof message === "function" ? message() : message, error);
+        }
+    }
+    errorAsync(message, error) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isErrorEnabled) {
+                const msg = yield message();
+                this.handleErrorMessage(msg, error);
+            }
+        });
+    }
+    handleDebugMessage(message) {
+        //TODO Fire event?
+        this.logDebug(message);
+    }
+    handleInfoMessage(message) {
+        //TODO Fire event?
+        this.logInfo(message);
+    }
+    handleWarnMessage(message) {
+        //TODO Fire event?
+        this.logWarn(message);
+    }
+    handleErrorMessage(message, error) {
+        //TODO Fire event?
+        this.logError(message, error);
+    }
+}
+exports.default = LoggerBase;

package/dist/logging/logger.d.ts

@@ -0,0 +1,16 @@
+import { LogLevel } from "./log-level";
+export interface ILogger {
+    readonly isDebugEnabled: boolean;
+    readonly isInfoEnabled: boolean;
+    readonly isWarnEnabled: boolean;
+    readonly isErrorEnabled: boolean;
+    minimumLogLevel: LogLevel;
+    debug(message: (() => string) | string): void;
+    debugAsync(message: () => Promise<string>): Promise<void>;
+    info(message: (() => string) | string): void;
+    infoAsync(message: () => Promise<string>): Promise<void>;
+    warn(message: (() => string) | string): void;
+    warnAsync(message: () => Promise<string>): Promise<void>;
+    error(message: (() => string) | string, error?: Error): void;
+    errorAsync(message: () => Promise<string>, error?: Error): Promise<void>;
+}

package/dist/logging/logger.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/logging/null-logger.d.ts

@@ -0,0 +1,7 @@
+import LoggerBase from "./logger-base";
+export default class NullLogger extends LoggerBase {
+    logDebug(message: string): void;
+    logInfo(message: string): void;
+    logWarn(message: string): void;
+    logError(message: string | Error, error?: Error): void;
+}

package/dist/logging/null-logger.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_base_1 = __importDefault(require("./logger-base"));
+class NullLogger extends logger_base_1.default {
+    logDebug(message) { }
+    logInfo(message) { }
+    logWarn(message) { }
+    logError(message, error) { }
+}
+exports.default = NullLogger;

package/dist/mappers/api-resource-mapper.d.ts

@@ -0,0 +1,5 @@
+import { ApiInfo } from "../api/api-info";
+import { ApiInfoResource } from "../api/api-info-resource";
+export declare class ApiResourceMapper {
+    static map(resource: ApiInfoResource): ApiInfo;
+}

package/dist/mappers/api-resource-mapper.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiResourceMapper = void 0;
+const api_info_1 = require("../api/api-info");
+const api_routes_dictionary_1 = require("../api/api-routes-dictionary");
+class ApiResourceMapper {
+    static map(resource) {
+        const apiRoutes = new api_routes_dictionary_1.ApiRoutesDictionary();
+        for (const [key, value] of Object.entries(resource.routes)) {
+            apiRoutes[key] = value;
+        }
+        const apiInfo = new api_info_1.ApiInfo(resource.fileVersion, resource.minimumSdkVersion, apiRoutes);
+        return apiInfo;
+    }
+}
+exports.ApiResourceMapper = ApiResourceMapper;