@sitecore/sc-contenthub-webclient-sdk 0.9.7

package/dist/contracts/base/member-condition.d.ts

@@ -0,0 +1,48 @@
+export interface IMemberCondition {
+    memberName: string;
+}
+export declare class MemberCondition implements IMemberCondition {
+    readonly memberName: string;
+    constructor(memberName: string);
+}
+/**
+ * Condition triggered if the relation does not have ancestor of given definition id.
+ */
+export declare class NoAncestorMemberCondition extends MemberCondition {
+    /**
+     * Gets or sets id of the linked {@link IEntityDefinition}.
+     */
+    definitionId: number;
+    constructor(memberName: string, definitionId: number);
+}
+/**
+ * Condition triggered on the value of the property.
+ */
+export declare class StringMemberCondition extends MemberCondition {
+    /**
+     * Non null case insensitive and culture agnostic value which is compared against entity property value.
+     * Note that the value equal to an empty string is treated as unspecified value not triggering the condition.
+     */
+    value: string;
+    constructor(memberName: string, value: string);
+}
+/**
+ * Condition triggered on the value of the property.
+ */
+export declare class BooleanMemberCondition extends MemberCondition {
+    /**
+     * Boolean value for the condition.
+     */
+    value: boolean;
+    constructor(memberName: string, value: boolean);
+}
+/**
+ * Condition triggered on ancestor id of the relation.
+ */
+export declare class RelationMemberCondition extends MemberCondition {
+    /**
+     * Id of the entity.
+     */
+    entityId: number;
+    constructor(memberName: string, entityId: number);
+}

package/dist/contracts/base/member-condition.js

@@ -0,0 +1,125 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationMemberCondition = exports.BooleanMemberCondition = exports.StringMemberCondition = exports.NoAncestorMemberCondition = exports.MemberCondition = void 0;
+const ta_json_1 = require("ta-json");
+const guard_1 = __importDefault(require("../../guard"));
+let MemberCondition = class MemberCondition {
+    constructor(memberName) {
+        this.memberName = memberName;
+    }
+};
+__decorate([
+    ta_json_1.JsonProperty("member"),
+    __metadata("design:type", String)
+], MemberCondition.prototype, "memberName", void 0);
+MemberCondition = __decorate([
+    ta_json_1.JsonObject(),
+    __metadata("design:paramtypes", [String])
+], MemberCondition);
+exports.MemberCondition = MemberCondition;
+// /**
+//  * Condition triggered on the value of the property member or ancestor id of the relation.
+//  */
+// export class MemberValueCondition extends MemberCondition {
+//     /**
+//      * Non {@link null} case insensitive and culture agnostic value which is compared against
+//      * entity property value or relation member taxonomy ancestors. Possible types of this
+//      * value are {@link string} or {@link number}.
+//      * Note that an empty string is treated as unspecified value not triggering the condition.
+//      */
+//     @JsonProperty("value")
+//     value: number|string;
+//
+//     constructor(memberName: string, value: number|string) {
+//         super(memberName);
+//         Guard.notNullOrUndefined(value);
+//
+//         this.value = value;
+//     }
+// }
+/**
+ * Condition triggered if the relation does not have ancestor of given definition id.
+ */
+let NoAncestorMemberCondition = class NoAncestorMemberCondition extends MemberCondition {
+    constructor(memberName, definitionId) {
+        super(memberName);
+        this.definitionId = definitionId;
+    }
+};
+__decorate([
+    ta_json_1.JsonProperty("definitionId"),
+    __metadata("design:type", Number)
+], NoAncestorMemberCondition.prototype, "definitionId", void 0);
+NoAncestorMemberCondition = __decorate([
+    ta_json_1.JsonObject(),
+    __metadata("design:paramtypes", [String, Number])
+], NoAncestorMemberCondition);
+exports.NoAncestorMemberCondition = NoAncestorMemberCondition;
+/**
+ * Condition triggered on the value of the property.
+ */
+let StringMemberCondition = class StringMemberCondition extends MemberCondition {
+    constructor(memberName, value) {
+        super(memberName);
+        guard_1.default.notNullOrUndefined(value);
+        this.value = value;
+    }
+};
+__decorate([
+    ta_json_1.JsonProperty("value"),
+    __metadata("design:type", String)
+], StringMemberCondition.prototype, "value", void 0);
+StringMemberCondition = __decorate([
+    ta_json_1.JsonObject(),
+    __metadata("design:paramtypes", [String, String])
+], StringMemberCondition);
+exports.StringMemberCondition = StringMemberCondition;
+/**
+ * Condition triggered on the value of the property.
+ */
+let BooleanMemberCondition = class BooleanMemberCondition extends MemberCondition {
+    constructor(memberName, value) {
+        super(memberName);
+        guard_1.default.notNullOrUndefined(value);
+        this.value = value;
+    }
+};
+__decorate([
+    ta_json_1.JsonProperty("value"),
+    __metadata("design:type", Boolean)
+], BooleanMemberCondition.prototype, "value", void 0);
+BooleanMemberCondition = __decorate([
+    ta_json_1.JsonObject(),
+    __metadata("design:paramtypes", [String, Boolean])
+], BooleanMemberCondition);
+exports.BooleanMemberCondition = BooleanMemberCondition;
+/**
+ * Condition triggered on ancestor id of the relation.
+ */
+let RelationMemberCondition = class RelationMemberCondition extends MemberCondition {
+    constructor(memberName, entityId) {
+        super(memberName);
+        this.entityId = entityId;
+    }
+};
+__decorate([
+    ta_json_1.JsonProperty("entityId"),
+    __metadata("design:type", Number)
+], RelationMemberCondition.prototype, "entityId", void 0);
+RelationMemberCondition = __decorate([
+    ta_json_1.JsonObject(),
+    __metadata("design:paramtypes", [String, Number])
+], RelationMemberCondition);
+exports.RelationMemberCondition = RelationMemberCondition;

package/dist/contracts/base/member-definition-type.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Describes the type of member.
+ */
+export declare enum MemberDefinitionType {
+    /**
+     * For properties.
+     */
+    Property = 0,
+    /**
+     * For relations.
+     */
+    Relation = 1
+}

package/dist/contracts/base/member-definition-type.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberDefinitionType = void 0;
+/**
+ * Describes the type of member.
+ */
+var MemberDefinitionType;
+(function (MemberDefinitionType) {
+    /**
+     * For properties.
+     */
+    MemberDefinitionType[MemberDefinitionType["Property"] = 0] = "Property";
+    /**
+     * For relations.
+     */
+    MemberDefinitionType[MemberDefinitionType["Relation"] = 1] = "Relation";
+})(MemberDefinitionType = exports.MemberDefinitionType || (exports.MemberDefinitionType = {}));

package/dist/contracts/base/member-definition.d.ts

@@ -0,0 +1,77 @@
+import { MapCultureTo } from "../../base-types";
+import DataType from "./data-type";
+import { IMemberCondition } from "./member-condition";
+import { MemberDefinitionType } from "./member-definition-type";
+import { IPropertyDefinition } from "./property-definition";
+import { BooleanPropertyDefinition, DateTimeOffsetPropertyDefinition, DateTimePropertyDefinition, DecimalPropertyDefinition, IntegerPropertyDefinition, JsonPropertyDefinition, LongPropertyDefinition, StringPropertyDefinition } from "./property-definitions";
+import { IRelationDefinition } from "./relation-definition";
+/**
+ * Base interface for all member definitions.
+ */
+export interface IMemberDefinition {
+    /**
+     * Data type of the member.
+     */
+    readonly type: DataType;
+    /**
+     * Type of the member definition.
+     */
+    readonly definitionType: MemberDefinitionType;
+    /**
+     * Language agnostic case insensitive name of the member.
+     * Must be unique per member and {@link IEntityDefinition}, except for self-referencing relations.
+     */
+    name: string;
+    /**
+     * Indicates whether this member can be updated from external sources (e.g. REST API, SDK...).
+     */
+    allowUpdates: boolean;
+    /**
+     * Indicates whether this member definition has any member conditions.
+     */
+    readonly isConditional: boolean;
+    /**
+     * The conditions that are evaluated to decide if this member should be exposed in the external API/UI.
+     * These conditions have no impact on data validity.
+     */
+    conditions: Array<IMemberCondition>;
+    /**
+     * Indicates if the member definition is owned by the system and cannot be modified or deleted by the regular users.
+     */
+    isSystemOwned: boolean;
+    /**
+     * Indicates if the read-write access to this member is restricted.
+     */
+    isSecured: boolean;
+    /**
+     * Collection of the culture specific member labels.
+     */
+    labels: MapCultureTo<string>;
+    /**
+     * Collection of the culture specific help text.
+     */
+    helpText: MapCultureTo<string>;
+}
+export declare abstract class MemberDefinition implements IMemberDefinition {
+    readonly type: DataType;
+    name: string;
+    allowUpdates: boolean;
+    isSystemOwned: boolean;
+    isSecured: boolean;
+    labels: MapCultureTo<string>;
+    helpText: MapCultureTo<string>;
+    conditions: Array<IMemberCondition>;
+    get isConditional(): boolean;
+    abstract get definitionType(): MemberDefinitionType;
+    constructor(name: string, type: DataType);
+    static isPropertyDefinition(definition: IMemberDefinition): definition is IPropertyDefinition;
+    static isStringPropertyDefinition(definition: IMemberDefinition): definition is StringPropertyDefinition;
+    static isIntegerPropertyDefinition(definition: IMemberDefinition): definition is IntegerPropertyDefinition;
+    static isLongPropertyDefinition(definition: IMemberDefinition): definition is LongPropertyDefinition;
+    static isDecimalPropertyDefinition(definition: IMemberDefinition): definition is DecimalPropertyDefinition;
+    static isBooleanPropertyDefinition(definition: IMemberDefinition): definition is BooleanPropertyDefinition;
+    static isDateTimePropertyDefinition(definition: IMemberDefinition): definition is DateTimePropertyDefinition;
+    static isDateTimeOffsetPropertyDefinition(definition: IMemberDefinition): definition is DateTimeOffsetPropertyDefinition;
+    static isJsonPropertyDefinition(definition: IMemberDefinition): definition is JsonPropertyDefinition;
+    static isRelationDefinition(definition: IMemberDefinition): definition is IRelationDefinition;
+}

package/dist/contracts/base/member-definition.js

@@ -0,0 +1,101 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberDefinition = void 0;
+const ta_json_1 = require("ta-json");
+const data_type_1 = __importDefault(require("./data-type"));
+const member_condition_1 = require("./member-condition");
+const member_definition_type_1 = require("./member-definition-type");
+let MemberDefinition = class MemberDefinition {
+    constructor(name, type) {
+        this.allowUpdates = true;
+        this.labels = {};
+        this.helpText = {};
+        this.conditions = [];
+        this.name = name;
+        this.type = type;
+    }
+    get isConditional() {
+        return !!this.conditions.length;
+    }
+    static isPropertyDefinition(definition) {
+        return definition.definitionType === member_definition_type_1.MemberDefinitionType.Property;
+    }
+    static isStringPropertyDefinition(definition) {
+        return this.isPropertyDefinition(definition) && definition.dataType === data_type_1.default.String;
+    }
+    static isIntegerPropertyDefinition(definition) {
+        return this.isPropertyDefinition(definition) && definition.dataType === data_type_1.default.Integer;
+    }
+    static isLongPropertyDefinition(definition) {
+        return this.isPropertyDefinition(definition) && definition.dataType === data_type_1.default.Long;
+    }
+    static isDecimalPropertyDefinition(definition) {
+        return this.isPropertyDefinition(definition) && definition.dataType === data_type_1.default.Decimal;
+    }
+    static isBooleanPropertyDefinition(definition) {
+        return this.isPropertyDefinition(definition) && definition.dataType === data_type_1.default.Boolean;
+    }
+    static isDateTimePropertyDefinition(definition) {
+        return this.isPropertyDefinition(definition) && definition.dataType === data_type_1.default.DateTime;
+    }
+    static isDateTimeOffsetPropertyDefinition(definition) {
+        return this.isPropertyDefinition(definition) && definition.dataType === data_type_1.default.DateTimeOffset;
+    }
+    static isJsonPropertyDefinition(definition) {
+        return this.isPropertyDefinition(definition) && definition.dataType === data_type_1.default.Json;
+    }
+    static isRelationDefinition(definition) {
+        return definition.definitionType === member_definition_type_1.MemberDefinitionType.Relation;
+    }
+};
+__decorate([
+    ta_json_1.JsonProperty("type"),
+    __metadata("design:type", String)
+], MemberDefinition.prototype, "type", void 0);
+__decorate([
+    ta_json_1.JsonProperty("name"),
+    __metadata("design:type", String)
+], MemberDefinition.prototype, "name", void 0);
+__decorate([
+    ta_json_1.JsonProperty("allow_updates"),
+    __metadata("design:type", Boolean)
+], MemberDefinition.prototype, "allowUpdates", void 0);
+__decorate([
+    ta_json_1.JsonProperty("is_system_owned"),
+    __metadata("design:type", Boolean)
+], MemberDefinition.prototype, "isSystemOwned", void 0);
+__decorate([
+    ta_json_1.JsonProperty("is_secured"),
+    __metadata("design:type", Boolean)
+], MemberDefinition.prototype, "isSecured", void 0);
+__decorate([
+    ta_json_1.JsonProperty("labels"),
+    __metadata("design:type", Object)
+], MemberDefinition.prototype, "labels", void 0);
+__decorate([
+    ta_json_1.JsonProperty("helptext"),
+    __metadata("design:type", Object)
+], MemberDefinition.prototype, "helpText", void 0);
+__decorate([
+    ta_json_1.JsonProperty("conditions"),
+    ta_json_1.JsonElementType(member_condition_1.MemberCondition),
+    __metadata("design:type", Array)
+], MemberDefinition.prototype, "conditions", void 0);
+MemberDefinition = __decorate([
+    ta_json_1.JsonObject(),
+    ta_json_1.JsonDiscriminatorProperty("type"),
+    __metadata("design:paramtypes", [String, String])
+], MemberDefinition);
+exports.MemberDefinition = MemberDefinition;

package/dist/contracts/base/member-group.d.ts

@@ -0,0 +1,54 @@
+import { MapCultureTo } from "../../base-types";
+import { IMemberCondition } from "./member-condition";
+import { IMemberDefinition } from "./member-definition";
+/**
+ * Member groups combine multiple members for the purpose of logical grouping, representation (API, UI) and/or access level.
+ */
+export interface IMemberGroup {
+    /**
+     * Language agnostic case insensitive name of the group.
+     * Must be unique per group and {@link IEntityDefinition}.
+     */
+    name: string;
+    /**
+     * Language agnostic case insensitive name of the content group.
+     * Used for grouping member groups for visual representation.
+     */
+    contentGroup: string;
+    /**
+     * Indicates if this member group is owned by the system and cannot be modified or deleted by the regular users.
+     */
+    isSystemOwned: boolean;
+    /**
+     * Indicates if this member group has conditions.
+     */
+    readonly isConditional: boolean;
+    /**
+     * The conditions that are evaluated to decide if this group should be exposed in the external API/UI.
+     * These conditions have no impact on data validity.
+     */
+    conditions: Array<IMemberCondition>;
+    /**
+     * Indicates if the read-write access to this member is restricted.
+     */
+    isSecured: boolean;
+    /**
+     * Collection the member definitions in this group.
+     */
+    memberDefinitions: Array<IMemberDefinition>;
+    /**
+     * Collection of the culture specific member labels.
+     */
+    labels: MapCultureTo<string>;
+}
+export declare class MemberGroup implements IMemberGroup {
+    name: string;
+    contentGroup: string;
+    isSystemOwned: boolean;
+    get isConditional(): boolean;
+    conditions: Array<IMemberCondition>;
+    isSecured: boolean;
+    memberDefinitions: Array<IMemberDefinition>;
+    labels: MapCultureTo<string>;
+    constructor(init?: Partial<IMemberGroup>);
+}

package/dist/contracts/base/member-group.js

@@ -0,0 +1,61 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberGroup = void 0;
+const ta_json_1 = require("ta-json");
+const member_condition_converter_1 = require("../../converters/member-condition-converter");
+const member_condition_1 = require("./member-condition");
+const member_definition_1 = require("./member-definition");
+let MemberGroup = class MemberGroup {
+    constructor(init) {
+        Object.assign(this, init);
+    }
+    // @JsonProperty("is_conditional")
+    get isConditional() {
+        return this.conditions != null && this.conditions.length > 0;
+    }
+};
+__decorate([
+    ta_json_1.JsonProperty("name"),
+    __metadata("design:type", String)
+], MemberGroup.prototype, "name", void 0);
+__decorate([
+    ta_json_1.JsonProperty("content_group"),
+    __metadata("design:type", String)
+], MemberGroup.prototype, "contentGroup", void 0);
+__decorate([
+    ta_json_1.JsonProperty("is_system_owned"),
+    __metadata("design:type", Boolean)
+], MemberGroup.prototype, "isSystemOwned", void 0);
+__decorate([
+    ta_json_1.JsonProperty("conditions"),
+    ta_json_1.JsonElementType(member_condition_1.MemberCondition),
+    ta_json_1.JsonConverter(member_condition_converter_1.MemberConditionConverter),
+    __metadata("design:type", Array)
+], MemberGroup.prototype, "conditions", void 0);
+__decorate([
+    ta_json_1.JsonProperty("is_secured"),
+    __metadata("design:type", Boolean)
+], MemberGroup.prototype, "isSecured", void 0);
+__decorate([
+    ta_json_1.JsonProperty("members"),
+    ta_json_1.JsonElementType(member_definition_1.MemberDefinition),
+    __metadata("design:type", Array)
+], MemberGroup.prototype, "memberDefinitions", void 0);
+__decorate([
+    ta_json_1.JsonProperty("labels"),
+    __metadata("design:type", Object)
+], MemberGroup.prototype, "labels", void 0);
+MemberGroup = __decorate([
+    ta_json_1.JsonObject(),
+    __metadata("design:paramtypes", [Object])
+], MemberGroup);
+exports.MemberGroup = MemberGroup;

package/dist/contracts/base/member.d.ts

@@ -0,0 +1,32 @@
+import { IDirtyTracking } from "../dirty-tracking/dirty-tracking";
+import { MemberDefinitionType } from "./member-definition-type";
+/**
+ * Base interface for all members (properties and relations).
+ */
+export interface IMember extends IDirtyTracking {
+    /**
+     * {@link MemberDefinition}
+     */
+    name: string;
+    /**
+     * The {@link MemberDefinitionType} of the member definition.
+     */
+    definitionType: MemberDefinitionType;
+}
+export declare abstract class MemberBase implements IMember {
+    name: string;
+    isTracking: boolean;
+    readonly definitionType: MemberDefinitionType;
+    abstract readonly isDirty: boolean;
+    abstract startTracking(): void;
+    abstract markClean(): void;
+    constructor(name: string, definitionType: MemberDefinitionType);
+    /**
+     * Returns a string representation of the current member instance.
+     *
+     * @remarks
+     * Can not be used for serialization. Only useful during debugging or testing.
+     * Returned format: \<member name\> ({@link MemberDefinitionType}) (\<constructor.name\>)
+     */
+    toString(): string;
+}

package/dist/contracts/base/member.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberBase = void 0;
+const guard_1 = __importDefault(require("../../guard"));
+const member_definition_type_1 = require("./member-definition-type");
+class MemberBase {
+    constructor(name, definitionType) {
+        guard_1.default.stringNotNullOrEmpty(name);
+        this.name = name;
+        this.definitionType = definitionType;
+    }
+    /**
+     * Returns a string representation of the current member instance.
+     *
+     * @remarks
+     * Can not be used for serialization. Only useful during debugging or testing.
+     * Returned format: \<member name\> ({@link MemberDefinitionType}) (\<constructor.name\>)
+     */
+    toString() {
+        return `${this.name} (${member_definition_type_1.MemberDefinitionType[this.definitionType]}) (${this.constructor.name})`;
+    }
+}
+exports.MemberBase = MemberBase;

package/dist/contracts/base/option-lists/flat-option-list-value.d.ts

@@ -0,0 +1,4 @@
+import { IFlatOptionListValue } from "./option-list-value";
+import OptionListValueBase from "./option-list-value-base";
+export default class FlatOptionListValue extends OptionListValueBase implements IFlatOptionListValue {
+}

package/dist/contracts/base/option-lists/flat-option-list-value.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const option_list_value_base_1 = __importDefault(require("./option-list-value-base"));
+class FlatOptionListValue extends option_list_value_base_1.default {
+}
+exports.default = FlatOptionListValue;

package/dist/contracts/base/option-lists/flat-option-list.d.ts

@@ -0,0 +1,9 @@
+import { ITypedOptionList } from "./option-list";
+import { TypedOptionListBase } from "./option-list-base";
+import { OptionListType } from "./option-list-type";
+import { IFlatOptionListValue } from "./option-list-value";
+export interface IFlatOptionList extends ITypedOptionList<IFlatOptionListValue> {
+}
+export default class FlatOptionList extends TypedOptionListBase<IFlatOptionListValue> implements IFlatOptionList {
+    readonly type: OptionListType;
+}

package/dist/contracts/base/option-lists/flat-option-list.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const option_list_base_1 = require("./option-list-base");
+const option_list_type_1 = require("./option-list-type");
+class FlatOptionList extends option_list_base_1.TypedOptionListBase {
+    constructor() {
+        super(...arguments);
+        this.type = option_list_type_1.OptionListType.Flat;
+    }
+}
+exports.default = FlatOptionList;

package/dist/contracts/base/option-lists/hierarchical-option-list.d.ts

@@ -0,0 +1,9 @@
+import { ITypedOptionList } from "./option-list";
+import { TypedOptionListBase } from "./option-list-base";
+import { OptionListType } from "./option-list-type";
+import { IHierarchicalOptionListValue } from "./option-list-value";
+export interface IHierarchicalOptionList extends ITypedOptionList<IHierarchicalOptionListValue> {
+}
+export default class HierarchicalOptionList extends TypedOptionListBase<IHierarchicalOptionListValue> implements IHierarchicalOptionList {
+    readonly type: OptionListType;
+}

package/dist/contracts/base/option-lists/hierarchical-option-list.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const option_list_base_1 = require("./option-list-base");
+const option_list_type_1 = require("./option-list-type");
+class HierarchicalOptionList extends option_list_base_1.TypedOptionListBase {
+    constructor() {
+        super(...arguments);
+        this.type = option_list_type_1.OptionListType.Hierarchical;
+    }
+}
+exports.default = HierarchicalOptionList;

package/dist/contracts/base/option-lists/hierarchical-options-list-value.d.ts

@@ -0,0 +1,7 @@
+import { MapCultureTo } from "../../../base-types";
+import { IHierarchicalOptionListValue } from "./option-list-value";
+import OptionListValueBase from "./option-list-value-base";
+export default class HierarchicalOptionListValue extends OptionListValueBase implements IHierarchicalOptionListValue {
+    readonly values: Array<IHierarchicalOptionListValue>;
+    constructor(identifier: string, labels?: MapCultureTo<string>, values?: Array<IHierarchicalOptionListValue>);
+}

package/dist/contracts/base/option-lists/hierarchical-options-list-value.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const option_list_value_base_1 = __importDefault(require("./option-list-value-base"));
+class HierarchicalOptionListValue extends option_list_value_base_1.default {
+    constructor(identifier, labels, values) {
+        super(identifier, labels);
+        //TODO add 'not all null' guard for values
+        this.values = values || [];
+    }
+}
+exports.default = HierarchicalOptionListValue;