@fluid-experimental/property-properties 0.59.1001-62246 → 0.59.2000

package/lib/properties/arrayProperty.d.ts

@@ -0,0 +1,315 @@
+export class ArrayProperty extends AbstractStaticCollectionProperty {
+    /**
+     * Default constructor for ArrayProperty
+     * @param {Object} [in_params] - the parameters
+     * @param {Number} [in_params.length = 0] the length of the array, if applicable
+     * @param {string} [in_scope] - The scope in which the property typeid is defined
+     * @protected
+     */
+    protected constructor();
+    _scope: string;
+    /**
+     * Insert into the array at a given position.
+     * It will not overwrite the existing values, it will push them to the right.
+     * @param {number} in_position target index
+     * @param {*} in_value inserted value or property
+     * @throws if in_position is smaller than zero, larger than the length of the array or not a number.
+     * @throws if trying to insert a property that already has a parent.
+     * @throws if trying to modify a referenced property.
+     * @throws if trying to insert a property that is a root property
+     */
+    insert(in_position: number, in_value: any): void;
+    /**
+     * Add one or more values at the end of the array
+     * @param {Array<property-properties.BaseProperty>|property-properties.BaseProperty|*|Array<*>} in_values
+     * the item or items to be pushed (either properties or values). If an array is passed, .push
+     *  will be called on each item in the array.
+     * @throws if trying to push a property that is a root property
+     * @return {number} new length of the array
+     */
+    push(in_values: any): number;
+    /**
+     * Add elements to the end of the queue (array)
+     */
+    enqueue(...args: any[]): number;
+    /**
+     * Add a value at the front of the array or letters to the beginning of a string (for StringProperty)
+     * It can also add multiple values to an array if you pass in an array of values.
+     * @param {Array<*>|*|Array<property-properties.BaseProperty>|property-properties.BaseProperty} in_values the values
+     * or properties to be pushed
+     * @throws if trying to insert a property that already has a parent.
+     * @throws if trying to insert a root property
+     * @throws if trying to modify a referenced property.
+     * @return {number} new length of the array
+     */
+    unshift(in_values: any): number;
+    /**
+     * Removes an element of the array (or a letter in a StringProperty) and shifts remaining elements to the left
+     * E.g. [1, 2, 3]   .remove(1) => [1, 3]
+     * E.g. (StringProperty) 'ABCDE'  .remove(1) => 'ACDE'
+     * @param {number} in_position the index that will be removed
+     * @throws if in_position is not a number
+     * @throws if trying to remove something that does not exist
+     * @throws if trying to remove an item with a parent
+     * @return {property-properties.BaseProperty | * } the value that was removed.
+     */
+    remove(in_position: number): any;
+    /**
+     * Removes the last element of the array or the last letter of a string (for StringProperty)
+     * @throws if trying to modify a referenced property
+     * @return {property-properties.BaseProperty|*} deleted element.
+     */
+    pop(): any;
+    /**
+     * Removes an element from the front of the array or a letter from the beginning of a string (for StringProperty)
+     * @return {*|property-properties.BaseProperty} the element removed.
+     */
+    shift(): any | any;
+    /**
+     * Removes elements from the front of the queue (array)
+     */
+    dequeue(): any;
+    /**
+     * Change an existing element of the array. This will overwrite an existing element.
+     * E.g. [1, 2, 3]  .set(1, 8) => [1, 8, 3]
+     * @param {number} in_position the target index
+     * @param {*} in_value the new property or value
+     * @throws if in_position is not a number
+     * @throws if in_position is smaller than zero
+     */
+    set(in_position: number, in_value: any): void;
+    /**
+     * @param {Array<*>|Object} in_values an array or object containing the values to be set.
+     * @see {setValues}
+     */
+    _setValuesInternal(in_values: Array<any> | any): void;
+    /**
+     * Deletes all values from an array
+     */
+    clear(): void;
+    /**
+     * Private helper function to update the internal dirty and pending changes
+     * is overwritten by StringProperty
+     *
+     * @param {property-properties.SerializedChangeSet} in_changeSet - The changeset to apply
+     * @private
+     */
+    private _updateChanges;
+    /**
+     * Returns the pending changeset for this object
+     * @return {property-properties.SerializedChangeSet} The pending changes
+     */
+    _getPendingChanges(): any;
+    /**
+     * Returns the dirty changeset for this object
+     * @return {property-properties.SerializedChangeSet} The dirty changes
+     */
+    _getDirtyChanges(): any;
+    /**
+     * Sets the pending and dirty changesets
+     *
+     * @param {property-properties.SerializedChangeSet|undefined|null} in_pending
+     *     The pending changeset. If null is passed, no change will be
+     *     applied. undefined indicates that the changes should be reset
+     * @param {property-properties.SerializedChangeSet|undefined|null} in_dirty
+     *     The dirty changeset. If null is passed, no change will be
+     *     applied. undefined indicates that the changes should be reset
+     */
+    _setChanges(in_pending: any, in_dirty: any): void;
+    /**
+     * Inserts the content of a given array into the array property
+     * It will not overwrite the existing values but push them to the right instead.
+     * E.g. [1, 2, 3] .insertRange(1, [9, 8]) => [1, 9, 8, 2, 3]
+     * @param {number} in_offset target index
+     * @param {Array<*>} in_array the array to be inserted
+     * @throws if in_offset is smaller than zero, larger than the length of the array or not a number.
+     * @throws if trying to insert a property that already has a parent.
+     * @throws if trying to modify a referenced property.
+     * @throws if trying to insert a property that is not an array.
+     * @throws if trying to insert a root property.
+     */
+    insertRange(in_offset: number, in_array: Array<any>): void;
+    /**
+     * inserts the content of a given array, but doesn't dirty the property
+     * this is useful for batch changes
+     * @param {number} in_offset target index
+     * @param {Array<*>} in_array the array to be inserted
+     * @param {Boolean=} [in_setParents=true] If true, set parent of inserted properties.
+     *                   If false, caller has already set parents.
+     * @private
+     */
+    private _insertRangeWithoutDirtying;
+    /**
+     * Removes a given number of elements from the array property (or given number of letters from a StringProperty)
+     *  and shifts remaining values to the left.
+     * E.g. [1, 2, 3, 4, 5]  .removeRange(1, 3) => [1, 5]
+     * @param {number} in_offset target start index
+     * @param {number} in_deleteCount number of elements to be deleted
+     * @throws if in_offset is not a number
+     * @throws if in_deleteCount is not a number
+     * @throws if trying to remove an item with a parent
+     * @throws if in_offset is smaller than zero or if in_offset + in_delete count is larger than the length of the array
+     * @return {Array<*>| Array<property-properties.BaseProperty>} an array containing the values or
+     *  properties removed.
+     */
+    removeRange(in_offset: number, in_deleteCount: number): Array<any> | Array<any>;
+    /**
+     * removes a given number of elements from the array property, and ensures, if this is not
+     * a primitive array, that any existing properties have their parent pointer cleared.
+     * @param {number} in_offset target start index
+     * @param {number} in_deleteCount number of elements to be deleted
+     * @private
+     */
+    private _clearRange;
+    /**
+     * removes a given number of elements from the array property, but doesn't dirty the property
+     * this is useful for batch changes
+     * @param {number} in_offset target start index
+     * @param {number} in_deleteCount number of elements to be deleted
+     * @private
+     */
+    private _removeRangeWithoutDirtying;
+    /**
+     * Sets the array properties elements to the content of the given array
+     * All changed elements must already exist. This will overwrite existing elements.
+     * E.g. [1, 2, 3, 4, 5]  .setRange(1, [7, 8]) => [1, 7, 8, 4, 5]
+     * @param {number} in_offset target start index
+     * @param {Array<*>|Array<property-properties.BaseProperty>} in_array contains the elements to be set
+     * @throws if in_offset is not a number
+     * @throws if in_offset is smaller than zero or higher than the length of the array
+     */
+    setRange(in_offset: number, in_array: any): void;
+    /**
+     * sets the array properties elements to the content of the given array
+     * all changed elements must already exist. This version doesn't dirty the property,
+     * which is useful for batch changes
+     * @param {number} in_offset target start index
+     * @param {Array<*>} in_array contains the elements to be set
+     */
+    _setRangeWithoutDirtying(in_offset: number, in_array: Array<any>): void;
+    /**
+     * sets the array properties elements to the content of the given array
+     * all changed elements must already exist. This version doesn't dirty the property,
+     * which is useful for batch changes
+     * @param {number} in_offset target start index
+     * @param {Array<*>} in_array contains the elements to be set
+     */
+    _modifyRangeWithoutDirtying(in_offset: number, in_array: Array<any>): void;
+    /**
+     * @return {Number} the current length of the array
+     */
+    getLength(): number;
+    /**
+     * Internal helper function that implements the deserialize algorithm for an array of named properties.
+     *
+     * @param {property-properties.SerializedChangeSet} in_serializedObj - The serialized changeset to apply. This
+     *     has to be a normalized change-set (only containing inserts. Removes and Modifies are forbidden).
+     * @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 {property-properties.SerializedChangeSet} ChangeSet with the changes that actually were performed during the
+     *     deserialization
+     */
+    _deserializeNamedPropertyArray(in_serializedObj: any, in_reportToView?: boolean): any;
+    /**
+     * Function to deserialize special primitive types.
+     * Some primitive types (e.g. Int64, which is not natively supported by javascript) require
+     * special treatment on deserialization. For supported types, we can just return the input here.
+     *
+     * @param {property-properties.SerializedChangeSet} in_serializedObj - The object to be deserialized
+     * @return {*} the deserialized value
+     */
+    _deserializeValue(in_serializedObj: any): any;
+    /**
+     * Function to serialize special primitive types.
+     * Some primitive types (e.g. Int64, which is not natively supported by javascript) require
+     * special treatment on serialization. For supported types, we can just return the input here.
+     *
+     * @param {*} in_obj - The object to be serialized
+     * @return {property-properties.SerializedChangeSet} the serialized object
+     */
+    _serializeValue(in_obj: any): any;
+    /**
+     * Function to serialize arrays of special primitive types.
+     * Some primitive types (e.g. Int64, which is not natively supported by javascript) require
+     * special treatment on serialization. For supported types, we can just return the input here.
+     *
+     * @param {Array} in_array - The array of special objects to be serialized
+     * @return {Array<property-properties.SerializedChangeSet>} the serialized object
+     */
+    _serializeArray(in_array: any[]): Array<any>;
+    /**
+     * Function to deserialize arrays of special primitive types.
+     * Some primitive types (e.g. Int64, which is not natively supported by javascript) require
+     * special treatment on deserialization. For supported types, we can just return the input here.
+     *
+     * @param {Array<property-properties.SerializedChangeSet>} in_serializedObj the serialized object
+     * @return {Array} in_array - The array of special objects that were deserialized
+     */
+    _deserializeArray(in_serializedObj: any): any[];
+    _getChangesetForCustomTypeArray(in_basePropertyChangeset: any, in_dirtinessType: any, in_includeReferencedRepositories: any): {
+        remove: any;
+        modify: any[];
+        insert: any[];
+    };
+    /**
+     * Creates and initializes the data array
+     * @param {Number} in_length      the initial length of the array
+     */
+    _dataArrayCreate(in_length: number): void;
+    _dataArrayRef: UniversalDataArray;
+    /**
+     * Returns the length of the data array
+     * @return {Number} The length
+     */
+    _dataArrayGetLength(): number;
+    /**
+     * Returns the data array's internal buffer
+     * @return {Array} The buffer
+     */
+    _dataArrayGetBuffer(): any[];
+    /**
+     * Returns an entry from the data array
+     * @param {Number} in_index - Position in the array
+     *
+     * @return {*} The value at index in_index
+     */
+    _dataArrayGetValue(in_index: number): any;
+    /**
+     * Sets an entry in the data array
+     * @param {Number} in_index - Position in the array
+     * @param {*}      in_value - The new value at index in_index
+     */
+    _dataArraySetValue(in_index: number, in_value: any): void;
+    /**
+     * Set the array to the given new array
+     * @param {Array} in_newArray - The new contents of the array
+     */
+    _dataArrayDeserialize(in_newArray: any[]): void;
+    /**
+     * Inserts a range into the data array
+     * @param {Number} in_position - Position at which the insert should be done
+     * @param {Array} in_range     - The array to insert
+     */
+    _dataArrayInsertRange(in_position: number, in_range: any[]): void;
+    /**
+     * Removes a range from the data array
+     * @param {Number} in_position - Position at which to start the removal
+     * @param {Number} in_length   - The number of entries to remove
+     */
+    _dataArrayRemoveRange(in_position: number, in_length: number): void;
+    /**
+     * Overwrites a range in the data array
+     * @param {Number} in_position - Position at which to start the removal
+     * @param {Array} in_range     - The array to overwrite
+     */
+    _dataArraySetRange(in_position: number, in_range: any[]): void;
+    set length(arg: number);
+    /**
+     * returns the length of the current array property
+     */
+    get length(): number;
+}
+import { AbstractStaticCollectionProperty } from "./abstractStaticCollectionProperty";
+import { UniversalDataArray } from "@fluid-experimental/property-common/dist/datastructures/dataArray";
+//# sourceMappingURL=arrayProperty.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arrayProperty.d.ts","sourceRoot":"","sources":["../../src/properties/arrayProperty.js"],"names":[],"mappings":"AA6IA;IACI;;;;;;OAMG;IACH,wBAaC;IAJO,eAAsB;IAqD9B;;;;;;;;;OASG;IACH,oBAPW,MAAM,uBAShB;IAaD;;;;;;;OAOG;IACH,sBAFY,MAAM,CASjB;IAED;;OAEG;IACH,gCAEC;IAED;;;;;;;;;OASG;IACH,yBAFY,MAAM,CASjB;IAED;;;;;;;;;OASG;IACH,oBANW,MAAM,OAUhB;IAED;;;;OAIG;IACH,WASC;IAED;;;OAGG;IACH,SAFY,SAAU,CAUrB;IAED;;OAEG;IACH,eAEC;IAED;;;;;;;OAOG;IACH,iBALW,MAAM,uBAUhB;IAwCD;;;OAGG;IACH,8BAHW,UAAQ,MAAO,QA8BzB;IAuBD;;OAEG;IACH,cAIC;IAYD;;;;;;OAMG;IACH,uBAUC;IAED;;;OAGG;IACH,0BAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;;;;;;;OASG;IACH,kDAwCC;IAoCD;;;;;;;;;;;OAWG;IACH,uBARW,MAAM,YACN,UAAQ,QAsBlB;IAED;;;;;;;;OAQG;IACH,oCAgCC;IAED;;;;;;;;;;;;OAYG;IACH,uBATW,MAAM,kBACN,MAAM,GAKL,UAAQ,GAAE,UAAc,CAkBnC;IAED;;;;;;OAMG;IACH,oBAYC;IAED;;;;;;OAMG;IACH,oCAQC;IAED;;;;;;;;OAQG;IACH,oBALW,MAAM,uBAmBhB;IAED;;;;;;OAMG;IACH,oCAHW,MAAM,YACN,UAAQ,QAIlB;IAED;;;;;;OAMG;IACH,uCAHW,MAAM,YACN,UAAQ,QAmClB;IA4HD;;OAEG;IACH,oBAEC;IAkJD;;;;;;;;;;OAUG;IACH,wEANW,OAAO,OA+JjB;IAED;;;;;;;OAOG;IACH,8CAEC;IAED;;;;;;;OAOG;IACH,kCAGC;IAED;;;;;;;OAOG;IACH,kCAFY,UAAc,CAezB;IAED;;;;;;;OAOG;IACH,gDAEC;IAyGD;;;;MA4GC;IAmJD;;;OAGG;IACH,0CASC;IANG,kCAAsD;IAQ1D;;;OAGG;IACH,8BAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;;;OAKG;IACH,0CAEC;IAED;;;;OAIG;IACH,0DAEC;IAED;;;OAGG;IACH,gDAEC;IAED;;;;OAIG;IACH,kEAEC;IAED;;;;OAIG;IACH,oEAEC;IAED;;;;OAIG;IACH,+DAEC;IAyBD,wBAEC;IARD;;OAEG;IACH,qBAEC;CAIJ"}