@fluid-experimental/property-properties 0.59.2000-61729 → 0.59.2000-63294

package/lib/properties/mapProperty.d.ts

@@ -0,0 +1,84 @@
+/**
+ * typedef {property-properties.BaseProperty|string|number|boolean} property-properties.MapProperty~MapValueType
+ *
+ * The type of the values that are set/inserted into the map. Depending on the type of the map, these can either
+ * be property objects or primitive values
+ */
+/**
+ * A MapProperty is a collection class that can contain an dictionary that maps from strings to properties.
+ */
+export class MapProperty extends IndexedCollectionBaseProperty {
+    /**
+     * @param {Object} in_params - Input parameters for property creation
+     * @param {string|undefined} in_scope - The scope in which the map typeid is defined
+     * @constructor
+     * @protected
+     * @extends property-properties.IndexedCollectionBaseProperty
+     * @alias property-properties.MapProperty
+     * @category Maps
+     */
+    protected constructor();
+    _scope: string;
+    _contextKeyType: any;
+    /** Contains the actual entries of the map */
+    _dynamicChildren: {};
+    /**
+     * Sets multiple values in a map.
+     *
+     * @param {object} in_values to assign to the collection
+     * @param {Boolean} in_typed - If the map's items have a typeid and a value then create the
+     *   properties with that typeid, else use the set's typeid (support polymorphic items).
+     * @see {setValues}
+     * @private
+     */
+    private _setValuesInternal;
+    /**
+     * Inserts a property or value into the map
+     *
+     * Note: This will trigger an exception when this key already exists in the map. If you want to overwrite
+     *       existing entries you can use the set function.
+     *
+     * @param {string}  in_key   - The key under which the entry is added
+     * @param {property-properties.Property}  in_property - The property to insert
+     * @throws if the property already exists
+     * @throws if the property already has a parent
+     * @throws if in_key is not a string
+     * @throws if the property is a root property
+     */
+    insert(in_key: string, in_property: any): void;
+    /**
+     * Removes the entry with the given key from the map
+     *
+     * @param {string} in_key - The key of the entry to remove from the map
+     * @throws if trying to remove an entry that does not exist
+     * @return {*} the item removed
+     */
+    remove(in_key: string): any;
+    /**
+     * Sets the entry with the given key to the property passed in
+     *
+     * Note: this will overwrite an already existing value
+     *
+     * @param {string}                                  in_key    - The key under which the entry is stored
+     * @param {property-properties.MapProperty~MapValueType}  in_property  - The property to store in the map
+     * @throws if in_property is not a property
+     * @throws if trying to insert a property that has a parent
+     * @throws if in_key is not a string or a number
+     */
+    set(in_key: string, in_property: any): void;
+    /**
+     * Returns all entries of the map as an array.
+     *
+     * NOTE: This function creates a copy and thus is less efficient as getEntriesReadOnly.
+     *
+     * @return {Array.<property-properties.BaseProperty | *>} Array with all entries of the map. This array
+     *     is a shallow copy which can be modified by the caller without effects on the map.
+     */
+    getAsArray(): Array<any>;
+    /**
+     * Deletes all values from the Map
+     */
+    clear(): void;
+}
+import { IndexedCollectionBaseProperty } from "./indexedCollectionBaseProperty";
+//# sourceMappingURL=mapProperty.d.ts.map

package/lib/properties/mapProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapProperty.d.ts","sourceRoot":"","sources":["../../src/properties/mapProperty.js"],"names":[],"mappings":"AAmBA;;;;;GAKG;AAEH;;GAEG;AACH;IACI;;;;;;;;OAQG;IACH,wBAQC;IALG,eAAsB;IACtB,qBAA2D;IAE3D,6CAA6C;IAC7C,qBAA0B;IA2B9B;;;;;;;;OAQG;IACH,2BAsCC;IA+FD;;;;;;;;;;;;OAYG;IACH,eAPW,MAAM,0BAsBhB;IAED;;;;;;OAMG;IACH,eAJW,MAAM,OAQhB;IAED;;;;;;;;;;OAUG;IACH,YANW,MAAM,0BAwBhB;IAwED;;;;;;;OAOG;IACH,cAHY,UAAe,CAK1B;IA8BD;;OAEG;IACH,cAKC;CACJ"}

package/lib/properties/namedNodeProperty.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A NamedNodeProperty is a NodeProperty that has a GUID which unique identifies the property object.
+ * This makes it possible to store it in a set collection.
+ */
+export class NamedNodeProperty extends NodeProperty {
+    /**
+     * @param {object} in_params         - List of parameters
+     * @param {string} in_params.id      - id of the property (null, if the GUID should be used for the ID)
+     * @param {string} in_params.typeid  - The type identifier
+     *
+     * @constructor
+     * @protected
+     * @extends property-properties.NodeProperty
+     * @alias property-properties.NamedNodeProperty
+     * @category Other Collections
+     */
+    protected constructor();
+    /**
+     * Return the URN for this named property
+     * @return {string} The URN
+     */
+    getUrn: any;
+}
+import { NodeProperty } from "./nodeProperty";
+//# sourceMappingURL=namedNodeProperty.d.ts.map

package/lib/properties/namedNodeProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namedNodeProperty.d.ts","sourceRoot":"","sources":["../../src/properties/namedNodeProperty.js"],"names":[],"mappings":"AAYA;;;GAGG;AACH;IACI;;;;;;;;;;OAUG;IACH,wBAEC;IAoBD;;;OAGG;IACH,YAAwC;CAC3C"}

package/lib/properties/namedProperty.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A NamedProperty has a URN which uniquely identifies the property object. This makes it possible to store it in a
+ * set collection.
+ */
+export class NamedProperty extends ContainerProperty {
+    /**
+     * @param {object} in_params         - List of parameters
+     * @param {string} in_params.id      - id of the property (null, if the GUID should be used for the ID)
+     * @param {string} in_params.typeid  - The type identifier
+     *
+     * @constructor
+     * @protected
+     * @extends property-properties.ContainerProperty
+     * @alias property-properties.NamedProperty
+     * @category Properties
+     */
+    protected constructor();
+}
+import { ContainerProperty } from "./containerProperty";
+//# sourceMappingURL=namedProperty.d.ts.map

package/lib/properties/namedProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namedProperty.d.ts","sourceRoot":"","sources":["../../src/properties/namedProperty.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH;IACI;;;;;;;;;;OAUG;IACH,wBAEC;CAqCJ"}

package/lib/properties/nodeProperty.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A property object that allows to add child properties dynamically.
+ */
+export class NodeProperty extends ContainerProperty {
+    /**
+     * @param {Object} in_params - Input parameters for property creation
+     *
+     * @constructor
+     * @protected
+     * @extends property-properties.ContainerProperty
+     * @alias property-properties.NodeProperty
+     * @category Other Collections
+     */
+    protected constructor();
+}
+import { ContainerProperty } from "./containerProperty";
+//# sourceMappingURL=nodeProperty.d.ts.map

package/lib/properties/nodeProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeProperty.d.ts","sourceRoot":"","sources":["../../src/properties/nodeProperty.js"],"names":[],"mappings":"AAUA;;GAEG;AACH;IACI;;;;;;;;OAQG;IACH,wBAGC;CAWJ"}

package/lib/properties/primitiveTypeCasts.d.ts

@@ -0,0 +1,15 @@
+export namespace _castFunctors {
+    function Uint64(in_value: number, in_radix?: number): number;
+    const Uint32: any;
+    const Uint16: any;
+    const Uint8: any;
+    function Int64(in_value: number, in_radix?: number): number;
+    const Int32: any;
+    const Int16: any;
+    const Int8: any;
+    const Float32: any;
+    const Float64: any;
+    function String(in_value: number): number;
+    function Boolean(in_value: boolean): boolean;
+}
+//# sourceMappingURL=primitiveTypeCasts.d.ts.map

package/lib/properties/primitiveTypeCasts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitiveTypeCasts.d.ts","sourceRoot":"","sources":["../../src/properties/primitiveTypeCasts.js"],"names":[],"mappings":";IAkDY,6DAWP;;;;IA8BM,4DAWN;;;;;;IA0CO,0CAEP;IAOQ,6CAER"}

package/lib/properties/referenceArrayProperty.d.ts

@@ -0,0 +1,47 @@
+/**
+ * An ArrayProperty which stores reference values
+ */
+export class ReferenceArrayProperty extends ValueArrayProperty {
+    /**
+     * Validates the array and returns a sanitized version of it containing only strings.
+     *
+     * @param {Array<property-properties.BaseProperty|undefined|String>} in_array  - contains the properties to be set or
+     *   the paths to those properties. If undefined is passed, the reference will be set to an empty string to
+     *   indicate an empty reference.
+     * @param {String} in_callerName  - the name of the function that called, to make it appear in
+     *   the error message if any
+     * @return {Array<string>} the array of paths
+     * @throws if in_array is not an array
+     * @throws if one of the items in in_array is defined, but is not a property or a string.
+     */
+    static _convertInputToPaths: (in_array: any, in_callerName: string) => Array<string>;
+    /**
+     * @param {Object} in_params - Input parameters for property creation
+     *
+     * @constructor
+     * @protected
+     * @extends property-properties.ArrayProperty
+     * @alias property-properties.ReferenceArrayProperty
+     * @category Arrays
+     */
+    protected constructor();
+    /**
+     * Returns the typeid for the target of this reference
+     *
+     * Note: This is the type that is specified in the typeid of this reference and not the actual type
+     * of the referenced object, which might inherit from that typeid.
+     *
+     * @return {string} The typeid of the nodes this reference may point to
+     */
+    getReferenceTargetTypeId(): string;
+    /**
+     * Checks whether the reference is valid. This is either the case when it is empty or when the referenced
+     * property exists.
+     *
+     * @param {number} in_position the target index
+     * @return {boolean} True if the reference is valid, otherwise false.
+     */
+    isReferenceValid(in_position: number): boolean;
+}
+import { ValueArrayProperty } from "./valueArrayProperty";
+//# sourceMappingURL=referenceArrayProperty.d.ts.map

package/lib/properties/referenceArrayProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"referenceArrayProperty.d.ts","sourceRoot":"","sources":["../../src/properties/referenceArrayProperty.js"],"names":[],"mappings":"AAgBA;;GAEG;AACH;IAgNI;;;;;;;;;;;OAWG;IACH,uEAJY,MAAM,MAAM,CAAC,CAcvB;IArOF;;;;;;;;OAQG;IACH,wBAEC;IAED;;;;;;;OAOG;IACH,4BAFY,MAAM,CAIjB;IAqCD;;;;;;OAMG;IACH,8BAHW,MAAM,GACL,OAAO,CAKlB;CAgKJ"}

package/lib/properties/referenceMapProperty.d.ts

@@ -0,0 +1,46 @@
+/**
+ * A StringMapProperty which stores reference values
+ */
+export class ReferenceMapProperty extends StringMapProperty {
+    /**
+     * @param {Object} in_params - Input parameters for property creation
+     *
+     * @constructor
+     * @protected
+     * @extends property-properties.StringMapProperty
+     * @alias property-properties.ReferenceMapProperty
+     * @category Maps
+     */
+    protected constructor();
+    /**
+     * Returns the typeid for the target of this reference
+     *
+     * Note: This is the type that is specified in the typeid of this reference and not the actual type
+     * of the referenced object, which might inherit from that typeid.
+     *
+     * @return {string} The typeid of the nodes this reference may point to
+     */
+    getReferenceTargetTypeId(): string;
+    /**
+     * Sets or inserts the reference to point to the given property object or to be equal to the given path string.
+     *
+     * @param {string} in_key - The key under which the entry is stored
+     * @param {property-properties.BaseProperty|undefined|String} in_value - The property to assign to the reference or
+     *   the path to this property. If undefined is passed, the reference will be set to an empty string to
+     *   indicate an empty reference.
+     * @throws if in_key is not a string
+     * @throws if in_value is defined, but is not a property or a string.
+     * @deprecated
+     */
+    setValue(...args: any[]): void;
+    /**
+     * Checks whether the reference is valid. This is either the case when it is empty or when the referenced
+     * property exists.
+     *
+     * @param {string} in_key - key of the entry to check
+     * @return {boolean} True if the reference is valid, otherwise false.
+     */
+    isReferenceValid(in_key: string): boolean;
+}
+import { StringMapProperty } from "./valueMapProperty";
+//# sourceMappingURL=referenceMapProperty.d.ts.map

package/lib/properties/referenceMapProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"referenceMapProperty.d.ts","sourceRoot":"","sources":["../../src/properties/referenceMapProperty.js"],"names":[],"mappings":"AAeA;;GAEG;AACH;IACI;;;;;;;;OAQG;IACH,wBAEC;IAED;;;;;;;OAOG;IACH,4BAFY,MAAM,CAIjB;IAqFD;;;;;;;;;;OAUG;IACH,+BAEC;IAiBD;;;;;;OAMG;IACH,yBAHW,MAAM,GACL,OAAO,CAMlB;CAuBJ"}

package/lib/properties/referenceProperty.d.ts

@@ -0,0 +1,59 @@
+/**
+ * This class serves as a view to read, write and listen to changes in an
+ * object's value field. To do this we simply keep a pointer to the object and
+ * it's associated data field that we are interested in. If no data field is
+ * present this property will have an undefined value.
+ */
+export class ReferenceProperty extends ValueProperty {
+    /**
+     * Validates the input and does as much as possible to return a string representing a path.
+     *
+     * @param {property-properties.BaseProperty|undefined|String} in_value  - contains the property to be set or
+     *  the path to this property. If undefined is passed, the reference will be set to an empty string to
+     *  indicate an empty reference.
+     * @return {string} the path
+     * @throws if in_value is defined, but is not a property or a string.
+     */
+    static _convertInputToPath(in_value: any): string;
+    /**
+    * @param {Object=} in_params - the parameters
+    *
+    * @constructor
+    * @protected
+    * @extends property-properties.ValueProperty
+    * @alias property-properties.ReferenceProperty
+    * @category Properties
+    */
+    protected constructor();
+    /**
+     * Returns the typeid for the target of this reference
+     *
+     * Note: This is the type that is specified in the typeid of this reference and not the actual type
+     * of the referenced object, which might inherit from that typeid.
+     *
+     * @return {string} The typeid of the nodes this reference may point to
+     */
+    getReferenceTargetTypeId(): string;
+    /**
+     * Checks whether the reference is valid. This is either the case when it is empty or when the referenced
+     * property exists.
+     *
+     * @return {boolean} True if the reference is valid, otherwise false.
+     */
+    isReferenceValid(): boolean;
+    /**
+     * Sets the reference to point to the given property object or to be equal to the given path string.
+     *
+     * @param {property-properties.BaseProperty|undefined|String} in_value - The property to assign to the reference or
+     *   the path to this property. If undefined is passed, the reference will be set to an empty string to
+     *   indicate an empty reference.
+     * @throws if property is read only
+     * @throws if in_value is defined but is not a property or a string.
+     */
+    set(...args: any[]): void;
+    set ref(arg: any);
+    get ref(): any;
+    _castFunctor: (in_value: number) => number;
+}
+import { ValueProperty } from "./valueProperty";
+//# sourceMappingURL=referenceProperty.d.ts.map

package/lib/properties/referenceProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"referenceProperty.d.ts","sourceRoot":"","sources":["../../src/properties/referenceProperty.js"],"names":[],"mappings":"AAgBA;;;;;GAKG;AACH;IAmKI;;;;;;;;OAQG;IACH,2CAHY,MAAM,CAkBjB;IA1LD;;;;;;;;MAQE;IACF,wBAIC;IAUD;;;;;;;OAOG;IACH,4BAFY,MAAM,CAIjB;IAoED;;;;;OAKG;IACH,oBAFY,OAAO,CAIlB;IAkBD;;;;;;;;OAQG;IACH,0BAEC;IAoBD,kBAEC;IAND,eAEC;IAgCL,2CAAwC;CADvC"}

package/lib/properties/setProperty.d.ts

@@ -0,0 +1,69 @@
+/**
+ * A SetProperty is a collection class that can contain an unordered set of properties. These properties
+ * must derive from NamedProperty and their URN is used to identify them within the set.
+ */
+export class SetProperty extends IndexedCollectionBaseProperty {
+    /**
+     * @param {Object} in_params - Input parameters for property creation
+     * @param {string|undefined} in_scope - The scope in which the map typeid is defined
+     *
+     * @constructor
+     * @protected
+     * @extends property-properties.IndexedCollectionBaseProperty
+     * @alias property-properties.SetProperty
+     * @category Other Collections
+     */
+    protected constructor();
+    _scope: string;
+    /** Contains the actual entries of the set, indexed by their GUID */
+    _dynamicChildren: {};
+    /**
+     * Inserts a property into the set
+     *
+     * @param {property-properties.NamedProperty} in_property - The property to insert
+     * @throws if trying to insert non-named properties
+     * @throws if trying to insert a property that has a parent
+     * @throws if a property already exists with the same guid as in_property
+     */
+    insert(in_property: any): void;
+    /**
+     * Adds a property to the set
+     * - If the property's key exists, the entry is replaced with new one.
+     * - If the property's key does not exist, the property is appended.*
+     *
+     * @param {NamedProperty|NamedNodeProperty|Object} in_property - The property to add to the list
+     */
+    set(in_property: any | any | any): void;
+    /**
+     * Removes the given property from the set
+     *
+     * @param {property-properties.NamedProperty|string} in_entry - The property or its URN to remove from the set
+     * @return {property-properties.NamedProperty} the property that was removed.
+     * @throws if trying to remove an entry that does not exist
+     */
+    remove(in_entry: any): any;
+    /**
+     * Adds a list of properties to the set.
+     * @see {setValues}
+     * @param {NamedProperty[]|NamedNodeProperty[]|Object[]} in_properties - The list of properties to add to the list
+     * @param {Boolean} in_typed - If the set's items have a typeid and a value then create the
+     *   properties with that typeid, else use the set's typeid (support polymorphic items).
+     * @private
+     */
+    private _setValuesInternal;
+    /**
+     * Returns all entries of the set as an array.
+     *
+     * NOTE: This function creates a copy and thus is less efficient as getEntriesReadOnly.
+     *
+     * @return {Array.<property-properties.NamedProperty>} Array with all entries of the set. This array is a shallow copy
+     * which can be modified by the caller without effects on the set.
+     */
+    getAsArray(): Array<any>;
+    /**
+     * Delete all values from Set
+     */
+    clear(): void;
+}
+import { IndexedCollectionBaseProperty } from "./indexedCollectionBaseProperty";
+//# sourceMappingURL=setProperty.d.ts.map

package/lib/properties/setProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setProperty.d.ts","sourceRoot":"","sources":["../../src/properties/setProperty.js"],"names":[],"mappings":"AAiBA;;;GAGG;AACH;IACI;;;;;;;;;OASG;IACH,wBAOC;IAJG,eAAsB;IAEtB,oEAAoE;IACpE,qBAA0B;IAmF9B;;;;;;;OAOG;IACH,+BAOC;IAED;;;;;;OAMG;IACH,iBAFW,eAAsC,QAehD;IAED;;;;;;OAMG;IACH,2BASC;IAwED;;;;;;;OAOG;IACH,2BAkBC;IAsCD;;;;;;;OAOG;IACH,cAHY,UAAe,CAK1B;IAmBD;;OAEG;IACH,cAKC;CACJ"}

package/lib/properties/stringProperty.d.ts

@@ -0,0 +1,39 @@
+/**
+ * A primitive property for a string value.
+ */
+export class StringProperty extends ValueArrayProperty {
+    /**
+     * @param {Object=} in_params - the parameters
+     * @constructor
+     * @protected
+     * @extends property-properties.ValueArrayProperty
+     * @alias property-properties.StringProperty
+     * @category Arrays
+     */
+    protected constructor();
+    /**
+     * inserts values
+     * @param {number} in_position target index
+     * @param {string} in_value the string to be inserted
+     */
+    _insertRange(in_position: number, in_value: string): void;
+    /**
+     * @param {string} in_value the new value
+     * @throws if string property is read only
+     */
+    setValue(in_value: string): void;
+    /**
+     * Internal function to update the value of a property
+     *
+     * @param {string} in_value the new value
+     * @param {boolean} [in_reportToView = true] - By default, the dirtying will always be reported to the checkout view
+     *                                             and trigger a modified event there. When batching updates, this
+     *                                             can be prevented via this flag.
+     * @return {boolean} true if the value was actually changed
+     */
+    _setValue(in_value: string, in_reportToView?: boolean): boolean;
+    set value(arg: string);
+    get value(): string;
+}
+import { ValueArrayProperty } from "./valueArrayProperty";
+//# sourceMappingURL=stringProperty.d.ts.map

package/lib/properties/stringProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringProperty.d.ts","sourceRoot":"","sources":["../../src/properties/stringProperty.js"],"names":[],"mappings":"AAuDA;;GAEG;AACH;IACI;;;;;;;OAOG;IACH,wBAEC;IA6FD;;;;OAIG;IACH,0BAHW,MAAM,YACN,MAAM,QAMhB;IA+ID;;;OAGG;IACH,mBAHW,MAAM,QAMhB;IA2BD;;;;;;;;OAQG;IACH,oBANW,MAAM,oBACN,OAAO,GAGN,OAAO,CAyBlB;IAoPD,uBAEC;IAND,oBAEC;CAeJ"}

package/lib/properties/uintProperties.d.ts

@@ -0,0 +1,47 @@
+/**
+ * A primitive property for an unsigned 8 bit integer value.
+ */
+export class Uint8Property extends ValueProperty {
+    /**
+     * @param {Object=} in_params - the parameters
+     * @constructor
+     * @private
+     * @extends property-properties.ValueProperty
+     * @alias property-properties.Uint8Property
+     * @category Value Properties
+     */
+    private constructor();
+    _castFunctor: any;
+}
+/**
+ * A primitive property for an unsigned 16 bit integer value.
+ */
+export class Uint16Property extends ValueProperty {
+    /**
+     * @param {Object=} in_params - the parameters
+     * @constructor
+     * @private
+     * @extends property-properties.ValueProperty
+     * @alias property-properties.Uint16Property
+     * @category Value Properties
+     */
+    private constructor();
+    _castFunctor: any;
+}
+/**
+ * A primitive property for an unsigned 32 bit integer value.
+ */
+export class Uint32Property extends ValueProperty {
+    /**
+     * @param {Object=} in_params - the parameters
+     * @constructor
+     * @protected
+     * @extends property-properties.ValueProperty
+     * @alias property-properties.Uint32Property
+     * @category Value Properties
+     */
+    protected constructor();
+    _castFunctor: any;
+}
+import { ValueProperty } from "./valueProperty";
+//# sourceMappingURL=uintProperties.d.ts.map

package/lib/properties/uintProperties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uintProperties.d.ts","sourceRoot":"","sources":["../../src/properties/uintProperties.js"],"names":[],"mappings":"AAWA;;GAEG;AACH;IACI;;;;;;;OAOG;IACH,sBAIC;IAGL,kBAAoC;CAFnC;AAID;;GAEG;AACH;IACI;;;;;;;OAOG;IACH,sBAIC;IAGL,kBAAqC;CAFpC;AAID;;GAEG;AACH;IACI;;;;;;;OAOG;IACH,wBAIC;IAGL,kBAAqC;CAFpC"}