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

package/lib/properties/baseProperty.d.ts

@@ -0,0 +1,594 @@
+import { ChangeSet, PathHelper, SerializedChangeSet } from '@fluid-experimental/property-changeset';
+/**
+ * Determines in which cases a reference will automatically be resolved
+ */
+declare enum REFERENCE_RESOLUTION {
+    /** The resolution will always automatically follow references */
+    ALWAYS = 0,
+    /** If a reference is the last entry during the path resolution, it will not automatically be resolved */
+    NO_LEAFS = 1,
+    /** References are never automatically resolved */
+    NEVER = 2
+}
+/**
+  * Used to indicate the state of a property. These flags can be connected via OR.
+  */
+declare enum MODIFIED_STATE_FLAGS {
+    /** No changes to this property at the moment */
+    CLEAN = 0,
+    /** The property is marked as changed in the currently pending ChangeSet */
+    PENDING_CHANGE = 1,
+    /** The property has been modified and the result has not yet been reported to the application for scene updates */
+    DIRTY = 2
+}
+interface IBasePropertyParams {
+    /** id of the property */
+    id?: string;
+    /** The type unique identifier */
+    typeid?: string;
+    /** The length of the property. Only valid if the property is an array, otherwise the length defaults to 1 */
+    length: number;
+    /** The type of property this template represents i.e. single, array, map, set. */
+    context: string;
+    /** List of property templates that are used to define children properties */
+    properties: BaseProperty[];
+    /**  List of property template typeids that this PropertyTemplate inherits from */
+    inherits: string[];
+}
+interface ISerializeOptions {
+    /** Only include dirty entries in the serialization */
+    dirtyOnly?: boolean;
+    /** Include the typeid of the root of the hierarchy */
+    includeRootTypeid?: boolean;
+    /** The type of dirtiness to use when reporting dirty changes. */
+    dirtinessType?: MODIFIED_STATE_FLAGS;
+    /**
+     * If this is set to true, the serialize
+     * function will descend into referenced repositories. WARNING: if there are loops in the references
+     * this can result in an infinite loop
+     */
+    includeReferencedRepositories?: boolean;
+}
+/**
+ * The options to selectively create only a subset of a property.
+ *
+ * For now the filtering options are propagated by many functions, but are actually used only by
+ * functions that create properties from schemas. It is then possible to create only a subset of
+ * the properties of a schema by providing a restricted list of paths.
+ *
+ * Thus, with the filtering options, it is NOT possible to prevent a part of a ChangeSet from being
+ * processed (in `applyChangeSet()` for example), it is NOT possible to prevent a property from being
+ * created by a direct call to a function like `deserialize()` or `createProperty()`.
+ *
+ */
+export declare abstract class BaseProperty {
+    protected _id: string | undefined;
+    protected _isConstant: boolean;
+    protected _dirty: MODIFIED_STATE_FLAGS;
+    protected _typeid: string;
+    protected _context: string;
+    protected _parent: BaseProperty | undefined;
+    protected _noDirtyInBase: boolean;
+    _tree: any;
+    _checkoutView: any;
+    _checkedOutRepositoryInfo: any;
+    constructor(in_params: IBasePropertyParams);
+    static MODIFIED_STATE_FLAGS: typeof MODIFIED_STATE_FLAGS;
+    static REFERENCE_RESOLUTION: typeof REFERENCE_RESOLUTION;
+    static PATH_TOKENS: {
+        /** A / at the beginning of the path */
+        ROOT: {
+            token: string;
+        };
+        /** A * that indicates a dereferencing operation */ REF: {
+            token: string;
+        };
+        /** A ../ that indicates one step above the current path */
+        UP: {
+            token: string;
+        };
+    };
+    /**
+     * @returns The typeid of this property
+     */
+    getTypeid(): string;
+    /**
+     * @returns The context of this property
+     */
+    getContext(): string;
+    /**
+     * Get the scope to which this property belongs to.
+     * @returns The guid representing the scope in which the
+     * property belongs to
+     */
+    protected _getScope(): string | undefined;
+    /**
+     * Returns the full property type identifier for the ChangeSet including the enum type id
+     * @param in_hideCollection - if true the collection type (if applicable) will be omitted
+     *                since that is not applicable here, this param is ignored
+     * @returns The typeid
+     */
+    getFullTypeid(in_hideCollection?: boolean): string;
+    /**
+     * Updates the parent for the property
+     *
+     * @param in_property - The parent property
+     */
+    protected _setParent(in_property: BaseProperty): void;
+    /**
+     * Is this property the root of the property set tree?
+     *
+     * @returns True if it is a root, otherwise false.
+     */
+    isRoot(): boolean;
+    /**
+     * Is this property the ancestor of in_otherProperty?
+     * Note: A property is not considered an ancestor of itself
+     * @param in_otherProperty - possible descendant
+     * @throws if in_otherProperty is not defined.
+     * @returns True if it is a ancestor, otherwise false.
+     */
+    isAncestorOf(in_otherProperty: BaseProperty): boolean;
+    /**
+     * Is this property the descendant of in_otherProperty?
+     * Note: A property is not considered a descendant of itself
+     * @param in_otherProperty - possible ancestor
+     * @throws if in_otherProperty is not defined.
+     * @returns True if it is a descendant, otherwise false.
+     */
+    isDescendantOf(in_otherProperty: BaseProperty): boolean;
+    /**
+     * Is this property a leaf node with regard to flattening?
+     *
+     * TODO: Which semantics should flattening have? It stops at primitive types and collections?
+     *
+     * @returns True if it is a leaf with regard to flattening
+     */
+    _isFlattenLeaf(): boolean;
+    /**
+     * Get the parent of this property
+     *
+     * @returns The parent of this property (or undefined if none exist)
+     */
+    getParent(): BaseProperty | undefined;
+    /**
+     * checks whether the property is dynamic (only properties inherting from NodeProperty are)
+     * @returns True if it is a dynamic property.
+     */
+    isDynamic(): boolean;
+    /**
+     * Sets the property as dirty and/or pending. This will add one or both flags if not already set and will
+     * do the same for its parent. This does not clear any flag, it only sets.
+     *
+     * @param in_reportToView - 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.
+     * @param in_callingChild - The child which is dirtying its parent
+     * @param in_flags - The flags to set.
+     * @private
+     */
+    _setDirty(in_reportToView?: boolean, in_callingChild?: BaseProperty, in_flags?: MODIFIED_STATE_FLAGS): void;
+    /**
+     * Sets the dirty flags for this property
+     * @param in_flags - The dirty flags
+     */
+    _setDirtyFlags(in_flags: MODIFIED_STATE_FLAGS): void;
+    /**
+     * Gets the dirty flags for this property
+     * @returns The dirty flags
+     */
+    _getDirtyFlags(): MODIFIED_STATE_FLAGS;
+    /**
+     * Helper function, which reports the fact that a property has been dirtied to the checkout view
+     * @private
+     */
+    _reportDirtinessToView(): void;
+    /**
+     * Modifies the property according to the given changeset
+     *
+     * @param in_changeSet - The changeset to apply
+     * @param {property-properties.BaseProperty.PathFilteringOptions} [in_filteringOptions]
+     *    The filtering options to consider while applying the ChangeSet.
+     * @throws if in_changeSet is invalid.
+     */
+    applyChangeSet(in_changeSet: SerializedChangeSet): void;
+    /**
+     * Modifies the property according to the given changeset
+     *
+     * Internal function.
+     *
+     * @param in_changeSet - The changeset to apply
+     * @param in_reportToView - 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.
+     * @param {property-properties.BaseProperty.PathFilteringOptions} [in_filteringOptions]
+     *    The filtering options to consider while applying the ChangeSet. For now it is only used to
+     *    control property creation, to prevent properties from being created outside the checked out
+     *    paths. It does not validate that a value inside the ChangeSet is outside those paths.
+     */
+    _applyChangeset(in_changeSet: SerializedChangeSet, in_reportToView?: boolean, in_filteringOptions?: any): void;
+    /**
+     * Re-apply dirty flags from changesets
+     *
+     * Internal function.
+     *
+     * @param in_pendingChangeSet - The pending changeset to apply
+     * @param in_dirtyChangeSet - The dirty changeset to apply
+     * @throws if changeset arguments are invalid.
+     */
+    _reapplyDirtyFlags(in_pendingChangeSet: SerializedChangeSet, in_dirtyChangeSet: SerializedChangeSet): void;
+    protected resolvePath(path: string, params?: any): BaseProperty;
+    /**
+     * Removes the dirtiness flag from this property
+     * @param {property-properties.BaseProperty.MODIFIED_STATE_FLAGS} [in_flags] - The flags to clean, if none are supplied all
+     *                                                                       will be removed
+     * @private
+     */
+    _cleanDirty(in_flags: any): void;
+    /**
+     * Removes the dirtiness flag from this property and recursively from all of its children
+     *
+     * @param in_flags - The flags to clean, if none are supplied all
+     *                                                                       will be removed
+     */
+    cleanDirty(in_flags: MODIFIED_STATE_FLAGS): void;
+    /**
+     * Indicates that the property has been modified and a corresponding modified call has not yet been sent to the
+     * application for runtime scene updates.
+     *
+     * @param  in_dirtinessType - The type of dirtiness to check for. By default this is DIRTY
+     * @returns Is the property dirty?
+     */
+    _isDirty(in_dirtinessType?: MODIFIED_STATE_FLAGS): boolean;
+    /**
+     * Indicates that the property has been modified and a corresponding modified call has not yet been sent to the
+     * application for runtime scene updates.
+     *
+     * @returns True if the property is dirty. False otherwise.
+     */
+    isDirty(): boolean;
+    /**
+     * The property has pending changes in the current ChangeSet.
+     * @returns True if the property has pending changes. False otherwise.
+     */
+    hasPendingChanges(): boolean;
+    /**
+     * Returns the ChangeSet of all sub-properties
+     *
+     * @returns The serialized changes
+     */
+    getPendingChanges(): ChangeSet;
+    /**
+     * Get the id of this property
+     *
+     * @returns The id of the property
+     */
+    getId(): string | undefined;
+    /**
+     * Sets the checkedOutRepositoryInfo.
+     * @param {property-properties.CheckoutView~CheckedOutRepositoryInfo} value - The checkedOut repository info.
+     * @protected
+     */
+    _setCheckoutView(value: any): void;
+    /**
+     * Returns the checkoutView
+     * @return {property-properties.CheckoutView} - the checkout view
+     */
+    _getCheckoutView(): any;
+    /**
+     * Returns the checkedOutRepositoryInfo.
+     * @return {property-properties.CheckoutView~CheckedOutRepositoryInfo} The checkedOut repository info.
+     * @protected
+     */
+    _getCheckedOutRepositoryInfo(): any;
+    /**
+     * Returns the Workspace
+     * @returns The workspace containing the property.
+     */
+    getWorkspace(): any;
+    /**
+     * Returns the path segment for a child
+     *
+     * @param in_childNode - The child for which the path is returned
+     *
+     * @returns The path segment to resolve the child property under this property
+     */
+    _getPathSegmentForChildNode(in_childNode: BaseProperty): string;
+    /**
+     * Resolves a direct child node based on the given path segment
+     *
+     * @param {String} in_segment                                   - The path segment to resolve
+     * @param {property-properties.PathHelper.TOKEN_TYPES} in_segmentType - The type of segment in the tokenized path
+     *
+     * @return {property-properties.BaseProperty|undefined} The child property that has been resolved
+     * @protected
+     */
+    _resolvePathSegment(in_segment: string, in_segmentType: PathHelper.TOKEN_TYPES): BaseProperty;
+    /**
+     * Set the id of this property
+     *
+     * @param {string} in_id - The id for this property
+     *
+     * @return {string} the new id
+     * @private
+     */
+    _setId(in_id: any): string | number;
+    /**
+     * Return a clone of this property
+     * @returns The cloned property
+     */
+    clone(): BaseProperty;
+    /**
+     * Returns true if the property is a primitive type
+     * @return {boolean} true if the property is a primitive type
+     */
+    isPrimitiveType(): boolean;
+    /**
+     * Get a flattened, tree like representation of this object and all of it's
+     * descendants. The flattening will stop at primitive properties and collections.
+     *
+     * For non-leaf nodes, it is possible to access the corresponding node object itself via the
+     * propertyNode member of the flattened representation (warning, this will overwrite a
+     * property of this name).
+     * TODO: Do we want to have this feature or is it to dangerous?
+     *
+     * @returns the flat representation
+     */
+    private _flatten;
+    /**
+     * Repeatedly calls back the given function with human-readable string representations
+     * of the property and of its sub-properties. By default it logs to the console.
+     * If printFct is not a function, it will default to console.log
+     * @param {function} [printFct=console.log] - Function to call for printing each property
+     */
+    prettyPrint(printFct: any): void;
+    /**
+     * Return a JSON representation of the properties and its children.
+     * @return {object} A JSON representation of the properties and its children.
+     * @private
+     */
+    _toJson(): {
+        id: string;
+        context: string;
+        typeid: string;
+        isConstant: boolean;
+        value: any[];
+    };
+    getIds(): string[];
+    get(id: string, params?: {
+        referenceResolutionMode: REFERENCE_RESOLUTION;
+    }): BaseProperty | undefined;
+    /**
+     * Repeatedly calls back the given function with human-readable string
+     * representations of the property and of its sub-properties.
+     * @param {string} indent - Leading spaces to create the tree representation
+     * @param {string} externalId - Name of the current property at the upper level.
+     *                              Used for arrays.
+     * @param {function} printFct - Function to call for printing each property
+     */
+    _prettyPrint(indent: any, externalId: any, printFct: any): void;
+    /**
+     * Repeatedly calls back the given function with human-readable string
+     * representations of the property's sub-properties.
+     * @param {string} indent - Leading spaces to create the tree representation
+     * @param {function} printFct - Function to call for printing each property
+     */
+    _prettyPrintChildren(indent: any, printFct: any): void;
+    /**
+     * Returns the possible paths from the given from_property to this property. If multiple paths
+     * through multiple repository references are possible, returns more than one path.
+     *
+     * @param {property-properties.BaseProperty} in_fromProperty - The node from which the
+     *     path is computed
+     * @return {Array<string | undefined>} The paths between from_property and this property
+     * will return an empty array if trying to get the path from a child repo to a parent repo.
+     * @private
+     */
+    _getPathsThroughRepoRef(in_fromProperty: any): any[];
+    /**
+     * Returns the possible paths from the given in_fromProperty to this property. If no direct paths
+     * exist, it returns an indirect path between the two properties.
+     *
+     * @param {property-properties.BaseProperty} in_fromProperty - The node from which the
+     *     path is computed
+     * @return {string} The path between the given in_fromProperty and this property
+     * @private
+     */
+    _getIndirectPath(in_fromProperty: any): string;
+    /**
+     * Returns the path from the given in_fromProperty to this property if a direct path
+     * exists between the two properties. Otherwise returns undefined.
+     *
+     * @param {property-properties.BaseProperty} in_fromProperty - The node from which the
+     *     path is computed
+     * @return {string} The path between the given in_fromProperty and this property
+     * @private
+     */
+    _getDirectPath(in_fromProperty: any): string;
+    /**
+     * Returns the possible paths from the given in_fromProperty to this property.
+     *
+     * @param {property-properties.BaseProperty} in_fromProperty - The node from which the
+     *     path is computed
+     * @return {Array<string>} The paths between the given in_fromProperty and this property
+     * @private
+     */
+    _getAllRelativePaths(in_fromProperty: any): any[];
+    /**
+     * Returns the path from the given fron_property to this node if such a path exists.
+     * If more than one paths exist (as might be the case with multiple repository references
+     * pointing to the same repository), it will return the first valid path found.
+     * For example, if you have this structure:
+     * <code>prop1
+     * --prop2
+     * ----prop3</code>
+     * and call: <code>prop1.getRelativePath(prop3);</code>
+     * You will get the path from prop3 to prop1, which would be '../../'
+     * @param in_fromProperty - The property from which the
+     *     path is computed
+     * @returns The path between the given in_fromProperty and this property
+     * @throws if in_fromProperty is not a property
+     */
+    getRelativePath(in_fromProperty: BaseProperty): string;
+    /**
+     * Returns the path from the root of the workspace to this node
+     * (including a slash at the beginning)
+     *
+     * @return {string} The path from the root
+     */
+    getAbsolutePath(): string;
+    /**
+     * Traverses the property hierarchy upwards until the a node without parent is reached
+     *
+     * @param {Function} in_callback - Callback to invoke for each of the parents. The traversal can be stopped
+     *                                 by returning BaseProperty.BREAK_TRAVERSAL
+     * @throws if in_callback is not a function.
+     * @return {string|undefined} Returns BaseProperty.BREAK_TRAVERSAL, if the traversal didn't reach the root,
+     *                            otherwise undefined
+     */
+    traverseUp(in_callback: any): any;
+    /**
+     * @type {string} Constant to stop the traversal in traverseUp and traverseDown functions
+     */
+    static BREAK_TRAVERSAL: string;
+    /**
+     * Returns all children which are dirty (this only returns direct children, it does not travers recursively)
+     *
+     * @param in_flags - Which types of dirtiness are we looking for?
+     *                   If none is given, all types are regarded as
+     *                   dirty
+     * @returns The list of keys identifying the dirty children
+     */
+    private _getDirtyChildren;
+    /**
+     * Returns the root of the property hierarchy
+     * @returns The root property
+     */
+    getRoot(): BaseProperty;
+    /**
+     * Traverses all children in the child hierarchy
+     * TODO: How should this behave for collections?
+     *
+     * @param in_callback             - Callback to invoke for every child
+     * @param in_pathFromTraversalStart - Path from the root of the traversal to this node
+     * @returns Returns BaseProperty.BREAK_TRAVERSAL if the traversal has been interrupted,
+     *                            otherwise undefined
+     * @private
+     */
+    _traverse(in_callback: Function, in_pathFromTraversalStart: string): string | undefined;
+    /**
+     * Deserialize takes a currently existing property and sets it to the hierarchy described in the normalized
+     * ChangeSet passed as parameter. It will return a ChangeSet that describes the difference between the
+     * current state of the property and the passed in normalized property
+     *
+     * @param in_serializedObj - The serialized changeset to apply to this node. This
+     *     has to be a normalized change-set (only containing insertions and property assignments. Deletes and Modify
+     *     must not appear)
+     * @param in_filteringOptions
+     *    The filtering options to consider while deserializing the property.
+     * @param in_createChangeSet
+     *    Should a changeset be created for this deserialization?
+     * @param in_reportToView
+     *    Usually the dirtying should be reported to the view and trigger a modified
+     *    event there. This can be prevented via this flag.
+     * @throws if called on a read-only property.
+     * @returns ChangeSet with the changes that actually were performed during the
+     *     deserialization
+     */
+    deserialize(in_serializedObj: SerializedChangeSet, in_filteringOptions?: {}, in_createChangeSet?: boolean, in_reportToView?: boolean): SerializedChangeSet;
+    /**
+     * Sets the property to the state in the given normalized changeset
+     *
+     * @param in_serializedObj - The serialized changeset to apply. This
+     *     has to be a normalized change-set (only containing inserts. Removes and Modifies are forbidden).
+     * @param in_reportToView - Usually the dirtying should be reported to the view
+     *     and trigger a modified event there. When batching updates, this can be prevented via this flag.
+     * @param in_filteringOptions
+     *    The filtering options to consider while deserializing the property.
+     * @param in_createChangeSet
+     *    Should a changeset be created for this deserialization?
+     * @returns ChangeSet with the changes that actually were performed during the
+     *     deserialization
+     */
+    _deserialize(in_serializedObj: SerializedChangeSet, in_reportToView: boolean, in_filteringOptions?: {}, in_createChangeSet?: boolean): SerializedChangeSet;
+    /**
+     * Serialize the property into a changeSet
+     *
+     * @param in_dirtyOnly - Only include dirty entries in the serialization
+     * @param in_includeRootTypeid - Include the typeid of the root of the hierarchy
+     * @param in_dirtinessType -
+     *     The type of dirtiness to use when reporting dirty changes. By default this is
+     *     PENDING_CHANGE
+     * @param in_includeReferencedRepositories - If this is set to true, the serialize
+     *     function will descend into referenced repositories. WARNING: if there are loops in the references
+     *     this can result in an infinite loop
+     *
+     * @returns The serialized representation of this property
+     */
+    _serialize(in_dirtyOnly?: boolean, in_includeRootTypeid?: boolean, in_dirtinessType?: MODIFIED_STATE_FLAGS, in_includeReferencedRepositories?: boolean): object;
+    /**
+     * Serialize the property
+     *
+     * @param in_options - Options for the serialization
+     * @throws if in_options is defined but is not an object.
+     * @returns The serialized representation of this property
+     */
+    serialize(in_options: ISerializeOptions): object;
+    /**
+     * Indicate that all static members have been added to the property
+     *
+     * This function is invoked by the PropertyFactory once all static members have been added to the template
+     * @protected
+     */
+    _signalAllStaticMembersHaveBeenAdded(): void;
+    /**
+     * Tests whether this property may be modified
+     * @param {checkConstant} in_checkConstant - Check if is readonly constant property
+     */
+    _checkIsNotReadOnly(in_checkConstant: any): void;
+    /**
+     * Set a property and its children as constants (readonly properties)
+     */
+    _setAsConstant(): void;
+    traverseDown(arg0: (prop: any) => void): void;
+    /**
+     * Unsets a property and its children as constants
+     */
+    _unsetAsConstant(): void;
+    /**
+     * Dirties this node and all of its children
+     *
+     * @param in_reportToView - 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.
+     * @private
+     */
+    _setDirtyTree(in_reportToView?: boolean): void;
+    /**
+     * Determines whether a property can be inserted as a child of another property
+     * This does NOT validate if the parent can accept the child property, it only validates if
+     * the child property can be inserted in the parent.
+     * @param in_targetParent - The parent property
+     * @throws if the property can not be inserted
+     */
+    _validateInsertIn(in_targetParent: BaseProperty): void;
+    /**
+     * TODO: Remove it later. Kept not to modify tests
+     *
+     * Validates if the property and all its children are covered by the given list of paths.
+     *
+     * This function is expected to be used before inserting the property into its parent. That is the
+     * reason for asking for the base path. This is the full path expected for this property.
+     *
+     * This function uses the canonical representation of the property paths.
+     *
+     * @param in_basePath - The property's absolute path in canonical form
+     * @param in_paths - The array of paths that we wonder if it covers the property and its children
+     * @returns If the property and all its children are included in the paths
+     * @private
+     */
+    _coveredByPaths(in_basePath: string, in_paths: string[]): boolean;
+    get _properties(): object;
+}
+export {};
+//# sourceMappingURL=baseProperty.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"baseProperty.d.ts","sourceRoot":"","sources":["../../src/properties/baseProperty.ts"],"names":[],"mappings":"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"}

package/lib/properties/boolProperty.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A primitive property for a boolean value
+ */
+export class BoolProperty extends ValueProperty {
+    /**
+     * @param in_params - the parameters
+     */
+    constructor(in_params: any);
+    _castFunctor: (in_value: boolean) => boolean;
+}
+import { ValueProperty } from "./valueProperty";
+//# sourceMappingURL=boolProperty.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"boolProperty.d.ts","sourceRoot":"","sources":["../../src/properties/boolProperty.js"],"names":[],"mappings":"AAYA;;GAEG;AACH;IACI;;OAEG;IACH,4BAIC;IAIL,6CAAmC;CAHlC"}