@sitecore/sc-contenthub-webclient-sdk 0.9.7

package/dist/mappers/condition-mapper.d.ts

@@ -0,0 +1,36 @@
+import { NullableResultPromise } from "../base-types";
+import { IExtendedContentHubClient } from "../clients/extended-client";
+import { ICondition } from "../contracts/policies/condition";
+import { ConditionResource } from "../models/policies/condition-resource";
+export declare class ConditionMapper {
+    /**
+     * Map condition resources to conditions.
+     * @param client - An instance of an extended Content Hub client
+     * @param conditionResources - A collection of resources to map
+     * @returns An array of conditions.
+     */
+    static mapToConditionsAsync(client: IExtendedContentHubClient, conditionResources: Array<ConditionResource>): Promise<Array<ICondition>>;
+    /**
+     * Map a condition resource to a condition instance.
+     * @param client - An instance of an extended Content Hub client
+     * @param conditionResource - A condition resource
+     * @returns A condition or null.
+     */
+    static mapToConditionAsync(client: IExtendedContentHubClient, conditionResource: ConditionResource): NullableResultPromise<ICondition>;
+    /**
+     * Map condition instances to condition resources.
+     * @param client - An instance of an extended Content Hub client
+     * @param conditions - A collection of conditions
+     * @returns An array of condition resources.
+     */
+    static mapToConditionResourcesAsync(client: IExtendedContentHubClient, conditions: Array<ICondition>): Promise<Array<ConditionResource>>;
+    /**
+     * Map a condition to a condition resource.
+     * @param client - An instance of an extended Content Hub client
+     * @param condition - A condition instance
+     * @returns A condition resource or null.
+     */
+    static mapToConditionResourceAsync(client: IExtendedContentHubClient, condition: ICondition): NullableResultPromise<ConditionResource>;
+    private static mapIdAsync;
+    private static mapEntityLinksAsync;
+}

package/dist/mappers/condition-mapper.js

@@ -0,0 +1,112 @@
+"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 });
+exports.ConditionMapper = void 0;
+const condition_1 = require("../contracts/policies/condition");
+const condition_resource_1 = require("../models/policies/condition-resource");
+class ConditionMapper {
+    /**
+     * Map condition resources to conditions.
+     * @param client - An instance of an extended Content Hub client
+     * @param conditionResources - A collection of resources to map
+     * @returns An array of conditions.
+     */
+    static mapToConditionsAsync(client, conditionResources) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (conditionResources == null) {
+                return [];
+            }
+            const list = [];
+            for (const conditionResource of conditionResources) {
+                const condition = yield this.mapToConditionAsync(client, conditionResource);
+                if (condition != null) {
+                    list.push(condition);
+                }
+            }
+            return list;
+        });
+    }
+    /**
+     * Map a condition resource to a condition instance.
+     * @param client - An instance of an extended Content Hub client
+     * @param conditionResource - A condition resource
+     * @returns A condition or null.
+     */
+    static mapToConditionAsync(client, conditionResource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (conditionResource == null) {
+                return null;
+            }
+            const condition = new condition_1.Condition();
+            condition.directEntityIds = yield this.mapIdAsync(client, conditionResource.directEntities);
+            condition.entityIds = yield this.mapIdAsync(client, conditionResource.entities);
+            return condition;
+        });
+    }
+    /**
+     * Map condition instances to condition resources.
+     * @param client - An instance of an extended Content Hub client
+     * @param conditions - A collection of conditions
+     * @returns An array of condition resources.
+     */
+    static mapToConditionResourcesAsync(client, conditions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (conditions == null) {
+                return [];
+            }
+            const resources = [];
+            for (const condition of conditions) {
+                const conditionResource = yield this.mapToConditionResourceAsync(client, condition);
+                if (conditionResource != null) {
+                    resources.push(conditionResource);
+                }
+            }
+            return resources;
+        });
+    }
+    /**
+     * Map a condition to a condition resource.
+     * @param client - An instance of an extended Content Hub client
+     * @param condition - A condition instance
+     * @returns A condition resource or null.
+     */
+    static mapToConditionResourceAsync(client, condition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (condition == null) {
+                return null;
+            }
+            const conditionResource = new condition_resource_1.ConditionResource();
+            conditionResource.directEntities = yield this.mapEntityLinksAsync(client, condition.directEntityIds);
+            conditionResource.entities = yield this.mapEntityLinksAsync(client, condition.entityIds);
+            return conditionResource;
+        });
+    }
+    //#region Private methods
+    static mapIdAsync(client, idLinks) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (idLinks == null) {
+                return [];
+            }
+            const list = yield client.linkHelper.idsFromEntitiesAsync(idLinks);
+            return list;
+        });
+    }
+    static mapEntityLinksAsync(client, entityLinks) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (entityLinks == null) {
+                return [];
+            }
+            const list = yield client.linkHelper.entitiesToLinksAsync(entityLinks);
+            return list;
+        });
+    }
+}
+exports.ConditionMapper = ConditionMapper;

package/dist/mappers/entity-definition-mapper.d.ts

@@ -0,0 +1,13 @@
+import { NullableResultPromise } from "../base-types";
+import { IExtendedContentHubClient } from "../clients/extended-client";
+import { IEntityDefinition } from "../contracts/base";
+import { EntityDefinitionCollectionResource } from "../models/entity-definition-collection-resource";
+import { EntityDefinitionResource } from "../models/entity-definition-resource";
+export declare class EntityDefinitionMapper {
+    private readonly _client;
+    private readonly _memberGroupMapper;
+    constructor(client: IExtendedContentHubClient);
+    mapEntityDefinitionsAsync(resources: Array<EntityDefinitionResource> | EntityDefinitionCollectionResource): Promise<Array<IEntityDefinition>>;
+    mapEntityDefinitionAsync(resource: EntityDefinitionResource): NullableResultPromise<IEntityDefinition>;
+    mapEntityDefinitionResourceAsync(definition: IEntityDefinition): NullableResultPromise<EntityDefinitionResource>;
+}

package/dist/mappers/entity-definition-mapper.js

@@ -0,0 +1,88 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityDefinitionMapper = void 0;
+const ta_json_1 = require("ta-json");
+const base_1 = require("../contracts/base");
+const guard_1 = __importDefault(require("../guard"));
+const entity_definition_resource_1 = require("../models/entity-definition-resource");
+const member_group_mapper_1 = require("./member-group-mapper");
+class EntityDefinitionMapper {
+    constructor(client) {
+        guard_1.default.notNullOrUndefined(client, "client");
+        this._client = client;
+        this._memberGroupMapper = new member_group_mapper_1.MemberGroupMapper(client);
+    }
+    //#region To SDK
+    mapEntityDefinitionsAsync(resources) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!resources)
+                return [];
+            if (!(resources instanceof Array)) {
+                resources = resources.items;
+            }
+            if (resources.length === 0)
+                return [];
+            const list = [];
+            for (const resource of resources) {
+                const entityDefinition = yield this.mapEntityDefinitionAsync(resource);
+                if (entityDefinition != null) {
+                    list.push(entityDefinition);
+                }
+            }
+            return list;
+        });
+    }
+    mapEntityDefinitionAsync(resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!resource)
+                return null;
+            const _a = ta_json_1.TaJson.deserialize(ta_json_1.TaJson.serialize(resource), entity_definition_resource_1.EntityDefinitionResource), { entities, relatedPaths, createdBy, modifiedBy, permissions, memberGroups, labels } = _a, definitionData = __rest(_a, ["entities", "relatedPaths", "createdBy", "modifiedBy", "permissions", "memberGroups", "labels"]);
+            const definition = new base_1.EntityDefinition(Object.assign(Object.assign({}, definitionData), { createdBy: (yield this._client.linkHelper.idFromEntityAsync(createdBy)) || undefined, modifiedBy: (yield this._client.linkHelper.idFromEntityAsync(modifiedBy)) || undefined, memberGroups: yield this._memberGroupMapper.mapMemberGroupsAsync(memberGroups), labels: JSON.parse(JSON.stringify(labels)) }));
+            return definition;
+        });
+    }
+    //#endregion
+    //#region To API resource
+    mapEntityDefinitionResourceAsync(definition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (definition == null)
+                return null;
+            const memberGroups = yield this._memberGroupMapper.mapMemberGroupResourcesAsync(definition.memberGroups);
+            return new entity_definition_resource_1.EntityDefinitionResource({
+                name: definition.name,
+                id: definition.id || 0,
+                displayTemplate: definition.displayTemplate,
+                isManualSortingAllowed: definition.isManualSortingAllowed,
+                isSystemOwned: definition.isSystemOwned,
+                isTaxonomyItemDefinition: definition.isTaxonomyItemDefinition,
+                isPathEnabledDefinition: definition.isPathEnabledDefinition,
+                memberGroups: memberGroups,
+                labels: JSON.parse(JSON.stringify(definition.labels)),
+            });
+        });
+    }
+}
+exports.EntityDefinitionMapper = EntityDefinitionMapper;

package/dist/mappers/entity-mapper.d.ts

@@ -0,0 +1,19 @@
+import { MapStringTo } from "../base-types";
+import { IExtendedContentHubClient } from "../clients/extended-client";
+import { IEntity } from "../contracts/base/entity";
+import { MinimalSchema } from "../contracts/querying/minimal-schema";
+import { EntityResource } from "../models/entity-resource";
+export declare class EntityMapper {
+    private readonly _client;
+    private readonly _propertyMapper;
+    private readonly _relationMapper;
+    private readonly _renditionMapper;
+    private readonly _creator;
+    constructor(client: IExtendedContentHubClient);
+    mapEntityAsync(resource: EntityResource, schema?: MinimalSchema): Promise<IEntity>;
+    mapEntitiesAsync(collection: Array<EntityResource>, schemas: MapStringTo<MinimalSchema>): Promise<Array<IEntity>>;
+    toResourceAsync(entity: IEntity): Promise<EntityResource>;
+    mapDirtiesToResourceAsync(entity: IEntity): Promise<EntityResource>;
+    private createEntityResourceAsync;
+    private mapBasePropertiesToSdkEntityAsync;
+}

package/dist/mappers/entity-mapper.js

@@ -0,0 +1,134 @@
+"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.EntityMapper = void 0;
+const entity_1 = require("../contracts/base/entity");
+const entity_construction_args_1 = require("../contracts/base/entity-construction-args");
+const guard_1 = __importDefault(require("../guard"));
+const entity_resource_1 = require("../models/entity-resource");
+const property_mapper_1 = require("./property-mapper");
+const relation_mapper_1 = require("./relation-mapper");
+const rendition_mapper_1 = require("./rendition-mapper");
+const typed_entity_creator_1 = require("./typed-entity-creator");
+class EntityMapper {
+    constructor(client) {
+        guard_1.default.notNullOrUndefined(client);
+        this._client = client;
+        this._propertyMapper = new property_mapper_1.PropertyMapper(client);
+        this._relationMapper = new relation_mapper_1.RelationMapper(client);
+        this._renditionMapper = new rendition_mapper_1.RenditionMapper(client);
+        this._creator = new typed_entity_creator_1.TypedEntityCreator(client);
+    }
+    mapEntityAsync(resource, schema) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(resource);
+            // The minimal schema is optional, but we should at least have a definition name.
+            const definitionName = (_a = schema === null || schema === void 0 ? void 0 : schema.definitionName) !== null && _a !== void 0 ? _a : (yield this._client.linkHelper.nameFromDefinitionAsync(resource.entityDefinition));
+            guard_1.default.notNullOrUndefined(definitionName);
+            guard_1.default.stringNotNullOrEmpty(definitionName);
+            const cultures = new Set(resource.cultures || []); //? Revisit usage of set
+            const properties = yield this._propertyMapper.mapPropertiesAsync(resource, [...cultures], schema);
+            const relations = yield this._relationMapper.mapRelationsAsync(resource, schema);
+            const renditions = this._renditionMapper.mapRenditions(resource.id, resource); //TODO: Extract extension data?
+            const args = new entity_construction_args_1.EntityConstructionArgs(definitionName, {
+                id: resource.id || 0,
+                identifier: resource.identifier,
+                cultures: [...cultures],
+                properties: properties,
+                relations: relations,
+                renditions: renditions,
+            });
+            const entity = new entity_1.Entity(this._client, args);
+            yield this.mapBasePropertiesToSdkEntityAsync(resource, entity);
+            entity.startTracking();
+            //TODO: Extension data
+            return entity;
+        });
+    }
+    mapEntitiesAsync(collection, schemas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(collection, "collection");
+            guard_1.default.notNullOrUndefined(schemas, "schemas");
+            const list = [];
+            for (const resource of collection) {
+                if (resource == null)
+                    continue;
+                const definitionName = (yield this._client.linkHelper.nameFromDefinitionAsync(resource.entityDefinition));
+                if (!schemas[definitionName]) {
+                    throw `Cannot map entity, missing minimal schema for definition '${definitionName}'.`;
+                }
+                const schema = schemas[definitionName];
+                const entity = yield this.mapEntityAsync(resource, schema);
+                list.push(entity);
+            }
+            return list;
+        });
+    }
+    toResourceAsync(entity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(entity);
+            const properties = property_mapper_1.PropertyMapper.mapToPropertyResources(entity);
+            const relations = yield this._relationMapper.mapToRelationResourcesAsync(entity);
+            const resource = yield this.createEntityResourceAsync(entity, properties, relations);
+            return resource;
+        });
+    }
+    mapDirtiesToResourceAsync(entity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(entity);
+            const properties = property_mapper_1.PropertyMapper.mapDirtyProperties(entity);
+            const relations = yield this._relationMapper.mapDirtyRelationsAsync(entity);
+            const resource = yield this.createEntityResourceAsync(entity, properties, relations);
+            return resource;
+        });
+    }
+    createEntityResourceAsync(entity, properties, relations) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const definitionLink = yield this._client.linkHelper.definitionToLinkAsync(entity.definitionName);
+            const resource = new entity_resource_1.EntityResource({
+                entityDefinition: definitionLink,
+                id: entity.id || 0,
+                identifier: entity.identifier,
+                isRootTaxonomyItem: entity.isRootTaxonomyItem,
+                isPathRoot: entity.isPathRoot,
+                inheritsSecurity: entity.inheritsSecurity,
+                isSystemOwned: entity.isSystemOwned,
+                properties: properties,
+                relations: relations,
+            });
+            return resource;
+        });
+    }
+    mapBasePropertiesToSdkEntityAsync(resource, entity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const createdBy = yield this._client.linkHelper.idFromEntityAsync(resource.createdBy);
+            const lockedBy = yield this._client.linkHelper.idFromEntityAsync(resource.lockedBy);
+            const modifiedBy = yield this._client.linkHelper.idFromEntityAsync(resource.modifiedBy);
+            //? Create deep copies
+            entity.inheritsSecurity = resource.inheritsSecurity;
+            entity.isSystemOwned = resource.isSystemOwned;
+            entity.lockedOn = resource.lockedOn || null;
+            entity.lockedBy = lockedBy;
+            entity.createdOn = resource.createdOn;
+            entity.createdBy = createdBy || undefined;
+            entity.modifiedOn = resource.modifiedOn;
+            entity.modifiedBy = modifiedBy || undefined;
+            entity.version = resource.version;
+            entity.isPathRoot = resource.isPathRoot;
+            entity.isRootTaxonomyItem = resource.isRootTaxonomyItem;
+        });
+    }
+}
+exports.EntityMapper = EntityMapper;

package/dist/mappers/final-life-cycle-status-mapper.d.ts

@@ -0,0 +1,6 @@
+import { Nullable } from "../base-types";
+import { FinalLifeCycleStatus } from "../contracts/content/final-life-cycle-status";
+export declare class FinalLifeCycleStatusMapper {
+    static fromString(status: Nullable<string>): Nullable<FinalLifeCycleStatus>;
+    static toString(status: Nullable<FinalLifeCycleStatus>): Nullable<string>;
+}

package/dist/mappers/final-life-cycle-status-mapper.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FinalLifeCycleStatusMapper = void 0;
+const string_format_1 = __importDefault(require("string-format"));
+const constants_1 = require("../constants");
+const final_life_cycle_status_1 = require("../contracts/content/final-life-cycle-status");
+const error_messages_1 = __importDefault(require("../error-messages"));
+class FinalLifeCycleStatusMapper {
+    static fromString(status) {
+        if (status == null) {
+            return null;
+        }
+        switch (status.toLowerCase()) {
+            case constants_1.DEFINITIONS["FinalLifeCycleStatus"].StatusValues.approved.toLowerCase():
+                return final_life_cycle_status_1.FinalLifeCycleStatus.Approved;
+            case constants_1.DEFINITIONS["FinalLifeCycleStatus"].StatusValues.archived.toLowerCase():
+                return final_life_cycle_status_1.FinalLifeCycleStatus.Archived;
+            case constants_1.DEFINITIONS["FinalLifeCycleStatus"].StatusValues.created.toLowerCase():
+                return final_life_cycle_status_1.FinalLifeCycleStatus.Created;
+            case constants_1.DEFINITIONS["FinalLifeCycleStatus"].StatusValues.rejected.toLowerCase():
+                return final_life_cycle_status_1.FinalLifeCycleStatus.Rejected;
+            case constants_1.DEFINITIONS["FinalLifeCycleStatus"].StatusValues.underReview.toLowerCase():
+                return final_life_cycle_status_1.FinalLifeCycleStatus.UnderReview;
+            default:
+                throw string_format_1.default(error_messages_1.default.FinalLifeCycleStatusMapper.UnknownStatus, status);
+        }
+    }
+    static toString(status) {
+        if (status == null) {
+            return null;
+        }
+        switch (status) {
+            case final_life_cycle_status_1.FinalLifeCycleStatus.Approved:
+                return constants_1.DEFINITIONS["FinalLifeCycleStatus"].StatusValues.approved;
+            case final_life_cycle_status_1.FinalLifeCycleStatus.Archived:
+                return constants_1.DEFINITIONS["FinalLifeCycleStatus"].StatusValues.archived;
+            case final_life_cycle_status_1.FinalLifeCycleStatus.Created:
+                return constants_1.DEFINITIONS["FinalLifeCycleStatus"].StatusValues.created;
+            case final_life_cycle_status_1.FinalLifeCycleStatus.Rejected:
+                return constants_1.DEFINITIONS["FinalLifeCycleStatus"].StatusValues.rejected;
+            case final_life_cycle_status_1.FinalLifeCycleStatus.UnderReview:
+                return constants_1.DEFINITIONS["FinalLifeCycleStatus"].StatusValues.underReview;
+            default:
+                throw string_format_1.default(error_messages_1.default.FinalLifeCycleStatusMapper.UnknownStatus, status);
+        }
+    }
+}
+exports.FinalLifeCycleStatusMapper = FinalLifeCycleStatusMapper;

package/dist/mappers/load-options-mapper.d.ts

@@ -0,0 +1,16 @@
+import { Nullable } from "../base-types";
+import { ICultureLoader } from "../clients/culture-loader";
+import { ICultureLoadOption } from "../contracts/querying/culture-load-option";
+import { EntityLoadConfiguration, IEntityLoadConfiguration } from "../contracts/querying/entity-load-configuration";
+import { IPropertyLoadOption } from "../contracts/querying/property-load-option";
+import { IQueryLoadConfiguration, QueryLoadConfiguration } from "../contracts/querying/query-load-configuration";
+import { IRelationLoadOption } from "../contracts/querying/relation-load-option";
+import CultureInfo from "../culture-info";
+export declare class LoadOptionsMapper {
+    private static defaultCultures;
+    static toEntityLoadConfiguration(loadConfiguration?: IQueryLoadConfiguration): Nullable<EntityLoadConfiguration>;
+    static toQueryLoadConfiguration(loadConfiguration?: IEntityLoadConfiguration): Nullable<QueryLoadConfiguration>;
+    static mapPropertyLoadOptions(options: IPropertyLoadOption): Nullable<Array<string>>;
+    static mapRelationLoadOptions(options: IRelationLoadOption): Nullable<Array<string>>;
+    static mapCultureLoadOptionsAsync(options: ICultureLoadOption, loader: ICultureLoader): Promise<Array<CultureInfo>>;
+}

package/dist/mappers/load-options-mapper.js

@@ -0,0 +1,100 @@
+"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.LoadOptionsMapper = void 0;
+const entity_load_configuration_1 = require("../contracts/querying/entity-load-configuration");
+const load_options_1 = require("../contracts/querying/load-options");
+const query_load_configuration_1 = require("../contracts/querying/query-load-configuration");
+const guard_1 = __importDefault(require("../guard"));
+class LoadOptionsMapper {
+    static toEntityLoadConfiguration(loadConfiguration) {
+        var _a, _b, _c;
+        if (loadConfiguration == null)
+            return null;
+        return new entity_load_configuration_1.EntityLoadConfiguration(((_a = loadConfiguration.cultureLoadOption) === null || _a === void 0 ? void 0 : _a.deepClone()) || undefined, ((_b = loadConfiguration.propertyLoadOption) === null || _b === void 0 ? void 0 : _b.deepClone()) || undefined, ((_c = loadConfiguration.relationLoadOption) === null || _c === void 0 ? void 0 : _c.deepClone()) || undefined);
+    }
+    static toQueryLoadConfiguration(loadConfiguration) {
+        var _a, _b, _c;
+        if (loadConfiguration == null)
+            return null;
+        return new query_load_configuration_1.QueryLoadConfiguration({
+            cultureLoadOption: ((_a = loadConfiguration.cultureLoadOption) === null || _a === void 0 ? void 0 : _a.deepClone()) || undefined,
+            propertyLoadOption: ((_b = loadConfiguration.propertyLoadOption) === null || _b === void 0 ? void 0 : _b.deepClone()) || undefined,
+            relationLoadOption: ((_c = loadConfiguration.relationLoadOption) === null || _c === void 0 ? void 0 : _c.deepClone()) || undefined,
+        });
+    }
+    static mapPropertyLoadOptions(options) {
+        if (options == null) {
+            return [];
+        }
+        let result = [];
+        switch (options.loadOption) {
+            case load_options_1.LoadOption.All:
+                result = null;
+                break;
+            case load_options_1.LoadOption.Custom:
+                if (options.properties != null) {
+                    result = options.properties;
+                }
+                break;
+        }
+        return result;
+    }
+    static mapRelationLoadOptions(options) {
+        if (options == null) {
+            return [];
+        }
+        let result = [];
+        switch (options.loadOption) {
+            case load_options_1.LoadOption.All:
+                result = null;
+                break;
+            case load_options_1.LoadOption.Custom:
+                if (options.relations != null) {
+                    result = options.relations.map(relationSpecification => relationSpecification.name);
+                }
+                break;
+        }
+        return result;
+    }
+    static mapCultureLoadOptionsAsync(options, loader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (options == null) {
+                return [];
+            }
+            let result = [];
+            switch (options.loadOption) {
+                case load_options_1.LoadOption.All:
+                    guard_1.default.notNullOrUndefined(loader);
+                    result = yield loader.getAllCulturesCachedAsync();
+                    break;
+                case load_options_1.LoadOption.Default:
+                    guard_1.default.notNullOrUndefined(loader);
+                    if (this.defaultCultures == null) {
+                        const defaultCulture = yield loader.getDefaultCultureCachedAsync();
+                        this.defaultCultures = defaultCulture != null ? [defaultCulture] : [];
+                    }
+                    result = this.defaultCultures;
+                    break;
+                case load_options_1.LoadOption.Custom:
+                    if (options.cultures != null) {
+                        result = options.cultures;
+                    }
+                    break;
+            }
+            return result;
+        });
+    }
+}
+exports.LoadOptionsMapper = LoadOptionsMapper;

package/dist/mappers/mapping-utilities.d.ts

@@ -0,0 +1,7 @@
+import { Nullable } from "../base-types";
+import { ICultureLoadOption } from "../contracts/querying/culture-load-option";
+import CultureInfo from "../culture-info";
+export declare class MappingUtilities {
+    static toNullableDate(dateTime?: Date): Nullable<Date>;
+    static culturesToLoadOption(cultures: Array<CultureInfo>): ICultureLoadOption;
+}

package/dist/mappers/mapping-utilities.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MappingUtilities = void 0;
+const culture_load_option_1 = require("../contracts/querying/culture-load-option");
+// TODO: complete this class
+class MappingUtilities {
+    //#region Dates
+    static toNullableDate(dateTime) {
+        return dateTime !== null && dateTime !== void 0 ? dateTime : null;
+    }
+    //#endregion
+    static culturesToLoadOption(cultures) {
+        if (cultures == null || cultures.length === 0) {
+            return culture_load_option_1.CultureLoadOption.None.deepClone();
+        }
+        return new culture_load_option_1.CultureLoadOption(cultures);
+    }
+}
+exports.MappingUtilities = MappingUtilities;

package/dist/mappers/member-condition-mapper.d.ts

@@ -0,0 +1,12 @@
+import { NullableResultPromise } from "../base-types";
+import { IExtendedContentHubClient } from "../clients/extended-client";
+import { IMemberCondition, MemberCondition } from "../contracts/base/member-condition";
+import { MemberConditionResource } from "../models/member-condition-resource";
+export declare class MemberConditionMapper {
+    private readonly _client;
+    constructor(client: IExtendedContentHubClient);
+    mapMemberConditionsAsync(conditionResources: Array<MemberConditionResource>): Promise<Array<MemberCondition>>;
+    mapMemberConditionAsync(conditionResource: MemberConditionResource): NullableResultPromise<MemberCondition>;
+    mapMemberConditionResourcesAsync(conditions: Array<IMemberCondition>): Promise<Array<MemberConditionResource>>;
+    mapMemberConditionResourceAsync(condition: IMemberCondition): NullableResultPromise<MemberConditionResource>;
+}