@hpcc-js/marshaller 2.28.7 → 2.28.9

package/src/ddl2/activities/activity.ts

@@ -1,431 +1,431 @@
-import { IMonitorHandle, PropertyExt } from "@hpcc-js/common";
-import { IField as WsEclField } from "@hpcc-js/comms";
-import { DDL2 } from "@hpcc-js/ddl-shim";
-import { hashSum, update } from "@hpcc-js/util";
-
-export function stringify(obj_from_json) {
-    if (Array.isArray(obj_from_json)) {
-        // not an object, stringify using native function
-        return "[" + obj_from_json.map(stringify).join(", ") + "]";
-    }
-    if (typeof obj_from_json !== "object" || obj_from_json === null || obj_from_json === undefined) {
-        // not an object, stringify using native function
-        return JSON.stringify(obj_from_json);
-    }
-    // Implements recursive object serialization according to JSON spec
-    // but without quotes around the keys.
-    const props = Object
-        .keys(obj_from_json)
-        .map(key => `${key}: ${stringify(obj_from_json[key])}`)
-        .join(", ");
-    return `{ ${props} }`;
-}
-
-export function schemaType2IFieldType(type): "boolean" | "number" | "number64" | "range" | "string" {
-    switch (type) {
-        case "boolean":
-            return "boolean";
-        case "xs:byte":
-        case "xs:double":
-        case "xs:decimal":
-        case "xs:float":
-        case "xs:int":
-        case "xs:short":
-        case "xs:unsignedInt":
-        case "xs:unsignedShort":
-        case "xs:unsignedByte":
-        case "number":
-            return "number";
-        case "xs:integer":
-        case "xs:long":
-        case "xs:negativeInteger":
-        case "xs:nonNegativeInteger":
-        case "xs:nonPositiveInteger":
-        case "xs:positiveInteger":
-        case "xs:unsignedLong":
-            return "number64";
-        case "string":
-            return "string";
-        case "range":
-            return "range";
-    }
-    return "string";
-}
-
-export function schemaRow2IField(row: any): DDL2.IField {
-    if (row._children && row._children.length) {
-        return {
-            type: "dataset",
-            id: row.name,
-            children: row._children.map(schemaRow2IField)
-        };
-    } else {
-        return {
-            id: row.name,
-            type: schemaType2IFieldType(row.type)
-        };
-    }
-}
-
-export function wsEclSchemaRow2IField(row: WsEclField): DDL2.IField {
-    return row;
-}
-
-export type ReferencedFields = {
-    inputs: { [activityID: string]: string[] },
-    outputs: { [activityID: string]: string[] }
-};
-
-export interface IActivityError {
-    source: string;
-    msg: string;
-    hint: string;
-}
-
-/*
-export const ROW_ID = "__##__";  //  TODO:  Should be Symbol
-export function rowID(row: Readonly<object>): undefined | number {
-    return row[ROW_ID] || row["__lparam"];
-}
-*/
-
-export abstract class Activity extends PropertyExt {
-    private _sourceActivity: Activity;
-
-    fixInt64(data) {
-        if (!data || data.length === 0) return [];
-        const int64Fields = this.outFields().filter(field => {
-            switch (field.type) {
-                case "number":
-                    //  Test actual data for integer64 cases.
-                    return typeof data[0][field.id] !== "number";
-                case "number64":
-                    return true;
-            }
-            return false;
-        });
-        if (int64Fields.length) {
-            return data.map(row => {
-                for (const int64Field of int64Fields) {
-                    row[int64Field.id] = +row[int64Field.id];
-                }
-                return row;
-            });
-        }
-        return data;
-    }
-
-    sourceActivity(): Activity;
-    sourceActivity(_: Activity): this;
-    sourceActivity(_?: Activity): Activity | this {
-        if (!arguments.length) return this._sourceActivity;
-        this._sourceActivity = _;
-        return this;
-    }
-
-    hash(more: object = {}): string {
-        return hashSum({
-            ...more
-        });
-    }
-
-    refreshMeta(): Promise<void> {
-        return this._sourceActivity ? this._sourceActivity.refreshMeta() : Promise.resolve();
-    }
-
-    exists(): boolean {
-        return true;
-    }
-
-    validate(): IActivityError[] {
-        return [];
-    }
-
-    label(): string {
-        return this.id();
-    }
-
-    updatedBy(): string[] {
-        return [];
-    }
-
-    private _emptyFields: ReadonlyArray<DDL2.IField> = [];
-    inFields(): ReadonlyArray<DDL2.IField> {
-        return this._sourceActivity ? this._sourceActivity.outFields() : this._emptyFields;
-    }
-
-    computeFields(inFields: ReadonlyArray<DDL2.IField>): () => ReadonlyArray<DDL2.IField> {
-        return () => inFields;
-    }
-
-    outFields(): ReadonlyArray<DDL2.IField> {
-        return this.computeFields(this.inFields())();
-    }
-
-    localFields(): DDL2.IField[] {
-        const inFieldIDs = this.inFields().map(field => field.id);
-        return this.outFields().filter(field => inFieldIDs.indexOf(field.id) < 0);
-    }
-
-    fieldOrigin(fieldID: string): Activity | null {
-        if (this.localFields().filter(field => field.id === fieldID).length) {
-            return this;
-        } else if (this.sourceActivity()) {
-            return this.sourceActivity().fieldOrigin(fieldID);
-        }
-        return null;
-    }
-
-    resolveFields(refs: ReferencedFields, fieldIDs: string[]) {
-        for (const fieldID of fieldIDs) {
-            const fieldOrigin = this.fieldOrigin(fieldID);
-            if (fieldOrigin) {
-                if (!refs.outputs[fieldOrigin.id()]) {
-                    refs.outputs[fieldOrigin.id()] = [];
-                }
-                if (refs.outputs[fieldOrigin.id()].indexOf(fieldID) < 0) {
-                    refs.outputs[fieldOrigin.id()].push(fieldID);
-                }
-            }
-        }
-    }
-
-    resolveInFields(refs: ReferencedFields, fieldIDs: string[]) {
-        return this._sourceActivity && this._sourceActivity.resolveFields(refs, fieldIDs);
-    }
-
-    referencedFields(refs: ReferencedFields): void {
-        this._sourceActivity && this._sourceActivity.referencedFields(refs);
-    }
-
-    exec(): Promise<void> {
-        return this._sourceActivity ? this._sourceActivity.exec() : Promise.resolve();
-    }
-
-    _emptyData: ReadonlyArray<object> = [];
-    inData(): ReadonlyArray<object> {
-        return this._sourceActivity ? this._sourceActivity.outData() || this._emptyData : this._emptyData;
-    }
-
-    computeData(): ReadonlyArray<object> {
-        return this.inData();
-    }
-
-    private _prevDataHash: string = "";
-    private _prevInData: ReadonlyArray<object> = [];
-    private _prevData: ReadonlyArray<object> = [];
-    private cachedComputeData(inData: ReadonlyArray<object>): ReadonlyArray<object> {
-        const hash = this.hash();
-        if (this._prevDataHash !== hash || this._prevInData !== inData) {
-            this._prevDataHash = hash;
-            this._prevInData = inData;
-            this._prevData = update(this._prevData, this.computeData());
-        }
-        return this._prevData;
-    }
-
-    outData(): ReadonlyArray<object> {
-        return this.cachedComputeData(this.inData());
-    }
-}
-
-export class ActivityArray extends Activity {
-    private _activities: Activity[] = [];
-
-    activities(): Activity[];
-    activities(_: Activity[]): this;
-    activities(_?: Activity[]): Activity[] | this {
-        if (!arguments.length) return this._activities;
-        this._activities = _;
-        return this;
-    }
-}
-ActivityArray.prototype._class += " ActivityArray";
-
-export class ActivityPipeline extends ActivityArray {
-
-    activities(): Activity[];
-    activities(_: Activity[]): this;
-    activities(_?: Activity[]): Activity[] | this {
-        if (!arguments.length) return super.activities();
-        super.activities(_);
-        let prevActivity: Activity;
-        for (const activity of _) {
-            if (prevActivity) {
-                activity.sourceActivity(prevActivity);
-            }
-            prevActivity = activity;
-        }
-        return this;
-    }
-
-    first(): Activity {
-        const retVal = this.activities();
-        return retVal[0];
-    }
-
-    last(): Activity | null {
-        const retVal = this.activities();
-        return retVal[retVal.length - 1];
-    }
-
-    protected calcUpdatedGraph(activity: Activity): Array<{ from: string, to: Activity }> {
-        return activity.updatedBy().map(source => {
-            return {
-                from: source,
-                to: activity
-            };
-        });
-    }
-
-    updatedByGraph(): Array<{ from: string, to: Activity }> {
-        let retVal: Array<{ from: string, to: Activity }> = [];
-        for (const activity of this.activities()) {
-            retVal = retVal.concat(this.calcUpdatedGraph(activity));
-        }
-        return retVal;
-    }
-
-    fetch(from: number = 0, count: number = Number.MAX_VALUE): Promise<ReadonlyArray<object>> {
-        return this.exec().then(() => {
-            const data = this.outData();
-            if (from === 0 && data.length <= count) {
-                return data;
-            }
-            return data.slice(from, from + count);
-        });
-    }
-
-    //  Activity overrides ---
-    hash(more: { [key: string]: any } = {}): string {
-        return hashSum({
-            activities: [this.activities().map(activity => activity.hash())],
-            ...more
-        });
-    }
-
-    refreshMeta(): Promise<void> {
-        return this.last().refreshMeta();
-    }
-
-    updatedBy(): string[] {
-        let retVal: string[] = [];
-        for (const activity of this.activities()) {
-            retVal = retVal.concat(activity.updatedBy());
-        }
-        return retVal;
-    }
-
-    inFields(): ReadonlyArray<DDL2.IField> {
-        return this.first().inFields();
-    }
-
-    outFields(): ReadonlyArray<DDL2.IField> {
-        return this.last().outFields();
-    }
-
-    localFields(): DDL2.IField[] {
-        return this.last().localFields();
-    }
-
-    fieldOrigin(fieldID: string): Activity | null {
-        return this.last().fieldOrigin(fieldID);
-    }
-
-    referencedFields(refs: ReferencedFields) {
-        this.last().referencedFields(refs);
-    }
-
-    resolveInFields(refs: ReferencedFields, fieldIDs: string[]) {
-        this.last().resolveInFields(refs, fieldIDs);
-    }
-
-    resolveFields(refs: ReferencedFields, fieldIDs: string[]) {
-        this.last().resolveFields(refs, fieldIDs);
-    }
-
-    exec(): Promise<void> {
-        return this.last().exec();
-    }
-
-    outData(): ReadonlyArray<object> {
-        return this.last().outData();
-    }
-}
-ActivityPipeline.prototype._class += " ActivitySequence";
-
-export class ActivitySelection extends ActivityArray {
-    private _selection: Activity;
-    private _monitorHandle: IMonitorHandle;
-
-    selection(): Activity;
-    selection(_: Activity): this;
-    selection(_?: Activity): Activity | this {
-        if (_ === undefined) return this._selection;
-        if (this._monitorHandle) {
-            this._monitorHandle.remove();
-        }
-        this._selection = _;
-        this._monitorHandle = _.monitor((id, newVal, oldVal) => {
-            this.broadcast(id, newVal, oldVal, _);
-        });
-        return this;
-    }
-
-    //  Activity overrides ---
-    hash(more: { [key: string]: any } = {}): string {
-        return hashSum({
-            selection: this.selection().hash(),
-            ...more
-        });
-    }
-
-    label(): string {
-        return this.selection().label();
-    }
-
-    refreshMeta(): Promise<void> {
-        return this.selection().refreshMeta();
-    }
-
-    updatedBy(): string[] {
-        return this.selection().updatedBy();
-    }
-
-    inFields(): ReadonlyArray<DDL2.IField> {
-        return this.selection().inFields();
-    }
-
-    outFields(): ReadonlyArray<DDL2.IField> {
-        return this.selection().outFields();
-    }
-
-    localFields(): DDL2.IField[] {
-        return this.selection().localFields();
-    }
-
-    fieldOrigin(fieldID: string): Activity | null {
-        return this.selection().fieldOrigin(fieldID);
-    }
-
-    referencedFields(refs: ReferencedFields) {
-        this.selection().referencedFields(refs);
-    }
-
-    resolveInFields(refs: ReferencedFields, fieldIDs: string[]) {
-        this.selection().resolveInFields(refs, fieldIDs);
-    }
-
-    resolveFields(refs: ReferencedFields, fieldIDs: string[]) {
-        this.selection().resolveFields(refs, fieldIDs);
-    }
-
-    exec(): Promise<void> {
-        return this.selection().exec();
-    }
-
-    outData(): ReadonlyArray<object> {
-        return this.selection().outData();
-    }
-}
-ActivitySelection.prototype._class += " ActivitySelection";
+import { IMonitorHandle, PropertyExt } from "@hpcc-js/common";
+import { IField as WsEclField } from "@hpcc-js/comms";
+import { DDL2 } from "@hpcc-js/ddl-shim";
+import { hashSum, update } from "@hpcc-js/util";
+
+export function stringify(obj_from_json) {
+    if (Array.isArray(obj_from_json)) {
+        // not an object, stringify using native function
+        return "[" + obj_from_json.map(stringify).join(", ") + "]";
+    }
+    if (typeof obj_from_json !== "object" || obj_from_json === null || obj_from_json === undefined) {
+        // not an object, stringify using native function
+        return JSON.stringify(obj_from_json);
+    }
+    // Implements recursive object serialization according to JSON spec
+    // but without quotes around the keys.
+    const props = Object
+        .keys(obj_from_json)
+        .map(key => `${key}: ${stringify(obj_from_json[key])}`)
+        .join(", ");
+    return `{ ${props} }`;
+}
+
+export function schemaType2IFieldType(type): "boolean" | "number" | "number64" | "range" | "string" {
+    switch (type) {
+        case "boolean":
+            return "boolean";
+        case "xs:byte":
+        case "xs:double":
+        case "xs:decimal":
+        case "xs:float":
+        case "xs:int":
+        case "xs:short":
+        case "xs:unsignedInt":
+        case "xs:unsignedShort":
+        case "xs:unsignedByte":
+        case "number":
+            return "number";
+        case "xs:integer":
+        case "xs:long":
+        case "xs:negativeInteger":
+        case "xs:nonNegativeInteger":
+        case "xs:nonPositiveInteger":
+        case "xs:positiveInteger":
+        case "xs:unsignedLong":
+            return "number64";
+        case "string":
+            return "string";
+        case "range":
+            return "range";
+    }
+    return "string";
+}
+
+export function schemaRow2IField(row: any): DDL2.IField {
+    if (row._children && row._children.length) {
+        return {
+            type: "dataset",
+            id: row.name,
+            children: row._children.map(schemaRow2IField)
+        };
+    } else {
+        return {
+            id: row.name,
+            type: schemaType2IFieldType(row.type)
+        };
+    }
+}
+
+export function wsEclSchemaRow2IField(row: WsEclField): DDL2.IField {
+    return row;
+}
+
+export type ReferencedFields = {
+    inputs: { [activityID: string]: string[] },
+    outputs: { [activityID: string]: string[] }
+};
+
+export interface IActivityError {
+    source: string;
+    msg: string;
+    hint: string;
+}
+
+/*
+export const ROW_ID = "__##__";  //  TODO:  Should be Symbol
+export function rowID(row: Readonly<object>): undefined | number {
+    return row[ROW_ID] || row["__lparam"];
+}
+*/
+
+export abstract class Activity extends PropertyExt {
+    private _sourceActivity: Activity;
+
+    fixInt64(data) {
+        if (!data || data.length === 0) return [];
+        const int64Fields = this.outFields().filter(field => {
+            switch (field.type) {
+                case "number":
+                    //  Test actual data for integer64 cases.
+                    return typeof data[0][field.id] !== "number";
+                case "number64":
+                    return true;
+            }
+            return false;
+        });
+        if (int64Fields.length) {
+            return data.map(row => {
+                for (const int64Field of int64Fields) {
+                    row[int64Field.id] = +row[int64Field.id];
+                }
+                return row;
+            });
+        }
+        return data;
+    }
+
+    sourceActivity(): Activity;
+    sourceActivity(_: Activity): this;
+    sourceActivity(_?: Activity): Activity | this {
+        if (!arguments.length) return this._sourceActivity;
+        this._sourceActivity = _;
+        return this;
+    }
+
+    hash(more: object = {}): string {
+        return hashSum({
+            ...more
+        });
+    }
+
+    refreshMeta(): Promise<void> {
+        return this._sourceActivity ? this._sourceActivity.refreshMeta() : Promise.resolve();
+    }
+
+    exists(): boolean {
+        return true;
+    }
+
+    validate(): IActivityError[] {
+        return [];
+    }
+
+    label(): string {
+        return this.id();
+    }
+
+    updatedBy(): string[] {
+        return [];
+    }
+
+    private _emptyFields: ReadonlyArray<DDL2.IField> = [];
+    inFields(): ReadonlyArray<DDL2.IField> {
+        return this._sourceActivity ? this._sourceActivity.outFields() : this._emptyFields;
+    }
+
+    computeFields(inFields: ReadonlyArray<DDL2.IField>): () => ReadonlyArray<DDL2.IField> {
+        return () => inFields;
+    }
+
+    outFields(): ReadonlyArray<DDL2.IField> {
+        return this.computeFields(this.inFields())();
+    }
+
+    localFields(): DDL2.IField[] {
+        const inFieldIDs = this.inFields().map(field => field.id);
+        return this.outFields().filter(field => inFieldIDs.indexOf(field.id) < 0);
+    }
+
+    fieldOrigin(fieldID: string): Activity | null {
+        if (this.localFields().filter(field => field.id === fieldID).length) {
+            return this;
+        } else if (this.sourceActivity()) {
+            return this.sourceActivity().fieldOrigin(fieldID);
+        }
+        return null;
+    }
+
+    resolveFields(refs: ReferencedFields, fieldIDs: string[]) {
+        for (const fieldID of fieldIDs) {
+            const fieldOrigin = this.fieldOrigin(fieldID);
+            if (fieldOrigin) {
+                if (!refs.outputs[fieldOrigin.id()]) {
+                    refs.outputs[fieldOrigin.id()] = [];
+                }
+                if (refs.outputs[fieldOrigin.id()].indexOf(fieldID) < 0) {
+                    refs.outputs[fieldOrigin.id()].push(fieldID);
+                }
+            }
+        }
+    }
+
+    resolveInFields(refs: ReferencedFields, fieldIDs: string[]) {
+        return this._sourceActivity && this._sourceActivity.resolveFields(refs, fieldIDs);
+    }
+
+    referencedFields(refs: ReferencedFields): void {
+        this._sourceActivity && this._sourceActivity.referencedFields(refs);
+    }
+
+    exec(): Promise<void> {
+        return this._sourceActivity ? this._sourceActivity.exec() : Promise.resolve();
+    }
+
+    _emptyData: ReadonlyArray<object> = [];
+    inData(): ReadonlyArray<object> {
+        return this._sourceActivity ? this._sourceActivity.outData() || this._emptyData : this._emptyData;
+    }
+
+    computeData(): ReadonlyArray<object> {
+        return this.inData();
+    }
+
+    private _prevDataHash: string = "";
+    private _prevInData: ReadonlyArray<object> = [];
+    private _prevData: ReadonlyArray<object> = [];
+    private cachedComputeData(inData: ReadonlyArray<object>): ReadonlyArray<object> {
+        const hash = this.hash();
+        if (this._prevDataHash !== hash || this._prevInData !== inData) {
+            this._prevDataHash = hash;
+            this._prevInData = inData;
+            this._prevData = update(this._prevData, this.computeData());
+        }
+        return this._prevData;
+    }
+
+    outData(): ReadonlyArray<object> {
+        return this.cachedComputeData(this.inData());
+    }
+}
+
+export class ActivityArray extends Activity {
+    private _activities: Activity[] = [];
+
+    activities(): Activity[];
+    activities(_: Activity[]): this;
+    activities(_?: Activity[]): Activity[] | this {
+        if (!arguments.length) return this._activities;
+        this._activities = _;
+        return this;
+    }
+}
+ActivityArray.prototype._class += " ActivityArray";
+
+export class ActivityPipeline extends ActivityArray {
+
+    activities(): Activity[];
+    activities(_: Activity[]): this;
+    activities(_?: Activity[]): Activity[] | this {
+        if (!arguments.length) return super.activities();
+        super.activities(_);
+        let prevActivity: Activity;
+        for (const activity of _) {
+            if (prevActivity) {
+                activity.sourceActivity(prevActivity);
+            }
+            prevActivity = activity;
+        }
+        return this;
+    }
+
+    first(): Activity {
+        const retVal = this.activities();
+        return retVal[0];
+    }
+
+    last(): Activity | null {
+        const retVal = this.activities();
+        return retVal[retVal.length - 1];
+    }
+
+    protected calcUpdatedGraph(activity: Activity): Array<{ from: string, to: Activity }> {
+        return activity.updatedBy().map(source => {
+            return {
+                from: source,
+                to: activity
+            };
+        });
+    }
+
+    updatedByGraph(): Array<{ from: string, to: Activity }> {
+        let retVal: Array<{ from: string, to: Activity }> = [];
+        for (const activity of this.activities()) {
+            retVal = retVal.concat(this.calcUpdatedGraph(activity));
+        }
+        return retVal;
+    }
+
+    fetch(from: number = 0, count: number = Number.MAX_VALUE): Promise<ReadonlyArray<object>> {
+        return this.exec().then(() => {
+            const data = this.outData();
+            if (from === 0 && data.length <= count) {
+                return data;
+            }
+            return data.slice(from, from + count);
+        });
+    }
+
+    //  Activity overrides ---
+    hash(more: { [key: string]: any } = {}): string {
+        return hashSum({
+            activities: [this.activities().map(activity => activity.hash())],
+            ...more
+        });
+    }
+
+    refreshMeta(): Promise<void> {
+        return this.last().refreshMeta();
+    }
+
+    updatedBy(): string[] {
+        let retVal: string[] = [];
+        for (const activity of this.activities()) {
+            retVal = retVal.concat(activity.updatedBy());
+        }
+        return retVal;
+    }
+
+    inFields(): ReadonlyArray<DDL2.IField> {
+        return this.first().inFields();
+    }
+
+    outFields(): ReadonlyArray<DDL2.IField> {
+        return this.last().outFields();
+    }
+
+    localFields(): DDL2.IField[] {
+        return this.last().localFields();
+    }
+
+    fieldOrigin(fieldID: string): Activity | null {
+        return this.last().fieldOrigin(fieldID);
+    }
+
+    referencedFields(refs: ReferencedFields) {
+        this.last().referencedFields(refs);
+    }
+
+    resolveInFields(refs: ReferencedFields, fieldIDs: string[]) {
+        this.last().resolveInFields(refs, fieldIDs);
+    }
+
+    resolveFields(refs: ReferencedFields, fieldIDs: string[]) {
+        this.last().resolveFields(refs, fieldIDs);
+    }
+
+    exec(): Promise<void> {
+        return this.last().exec();
+    }
+
+    outData(): ReadonlyArray<object> {
+        return this.last().outData();
+    }
+}
+ActivityPipeline.prototype._class += " ActivitySequence";
+
+export class ActivitySelection extends ActivityArray {
+    private _selection: Activity;
+    private _monitorHandle: IMonitorHandle;
+
+    selection(): Activity;
+    selection(_: Activity): this;
+    selection(_?: Activity): Activity | this {
+        if (_ === undefined) return this._selection;
+        if (this._monitorHandle) {
+            this._monitorHandle.remove();
+        }
+        this._selection = _;
+        this._monitorHandle = _.monitor((id, newVal, oldVal) => {
+            this.broadcast(id, newVal, oldVal, _);
+        });
+        return this;
+    }
+
+    //  Activity overrides ---
+    hash(more: { [key: string]: any } = {}): string {
+        return hashSum({
+            selection: this.selection().hash(),
+            ...more
+        });
+    }
+
+    label(): string {
+        return this.selection().label();
+    }
+
+    refreshMeta(): Promise<void> {
+        return this.selection().refreshMeta();
+    }
+
+    updatedBy(): string[] {
+        return this.selection().updatedBy();
+    }
+
+    inFields(): ReadonlyArray<DDL2.IField> {
+        return this.selection().inFields();
+    }
+
+    outFields(): ReadonlyArray<DDL2.IField> {
+        return this.selection().outFields();
+    }
+
+    localFields(): DDL2.IField[] {
+        return this.selection().localFields();
+    }
+
+    fieldOrigin(fieldID: string): Activity | null {
+        return this.selection().fieldOrigin(fieldID);
+    }
+
+    referencedFields(refs: ReferencedFields) {
+        this.selection().referencedFields(refs);
+    }
+
+    resolveInFields(refs: ReferencedFields, fieldIDs: string[]) {
+        this.selection().resolveInFields(refs, fieldIDs);
+    }
+
+    resolveFields(refs: ReferencedFields, fieldIDs: string[]) {
+        this.selection().resolveFields(refs, fieldIDs);
+    }
+
+    exec(): Promise<void> {
+        return this.selection().exec();
+    }
+
+    outData(): ReadonlyArray<object> {
+        return this.selection().outData();
+    }
+}
+ActivitySelection.prototype._class += " ActivitySelection";