@hpcc-js/marshaller 2.28.5 → 2.28.7

package/src/ddl2/activities/sort.ts

@@ -1,176 +1,176 @@
-import { PropertyExt, publish } from "@hpcc-js/common";
-import { DDL2 } from "@hpcc-js/ddl-shim";
-import { hashSum } from "@hpcc-js/util";
-import { ascending as d3Ascending, descending as d3Descending } from "d3-array";
-import { Activity, IActivityError, ReferencedFields } from "./activity";
-
-export class SortColumn extends PropertyExt {
-    private _owner: Sort;
-
-    @publish(null, "set", "Sort Field", function (this: SortColumn) { return this.fieldIDs(); }, {
-        optional: true,
-        validate: (w: SortColumn): boolean => w.fieldIDs().indexOf(w.fieldID()) >= 0
-    })
-    fieldID: publish<this, string>;
-    fieldID_valid: () => boolean;
-    @publish(false, "boolean", "Sort Field")
-    descending: publish<this, boolean>;
-
-    validate(prefix: string): IActivityError[] {
-        const retVal: IActivityError[] = [];
-        if (!this.fieldID_valid()) {
-            retVal.push({
-                source: `${prefix}.fieldID`,
-                msg: `Invalid fieldID:  ${this.fieldID()}`,
-                hint: `expected ${JSON.stringify(this.fieldIDs())}`
-            });
-        }
-        return retVal;
-    }
-
-    constructor() {
-        super();
-    }
-
-    owner(): Sort;
-    owner(_: Sort): this;
-    owner(_?: Sort): Sort | this {
-        if (!arguments.length) return this._owner;
-        this._owner = _;
-        return this;
-    }
-
-    valid(): boolean {
-        return !!this.fieldID();
-    }
-
-    toDDL(): DDL2.ISortCondition {
-        return {
-            fieldID: this.fieldID(),
-            descending: this.descending()
-        };
-    }
-
-    fromDDL(ddl: DDL2.ISortCondition): this {
-        return this
-            .fieldID(ddl.fieldID)
-            .descending(ddl.descending)
-            ;
-    }
-
-    static fromDDL(ddl: DDL2.ISortCondition): SortColumn {
-        return new SortColumn().fromDDL(ddl);
-    }
-
-    hash(): string {
-        return hashSum({
-            sortColumn: this.fieldID(),
-            descending: this.descending()
-        });
-    }
-
-    fieldIDs() {
-        return this._owner.fieldIDs();
-    }
-
-    field(id: string): DDL2.IField | undefined {
-        return this._owner.inFields().filter(field =>
-            field.id === id
-        )[0];
-    }
-}
-SortColumn.prototype._class += " SortColumn";
-
-//  ===========================================================================
-export class Sort extends Activity {
-    static Column = SortColumn;
-
-    @publish([], "propertyArray", "Source Columns", null, { autoExpand: SortColumn })
-    column: publish<this, SortColumn[]>;
-
-    validate(): IActivityError[] {
-        let retVal: IActivityError[] = [];
-        for (const sb of this.validSortBy()) {
-            retVal = retVal.concat(sb.validate("Sort.column"));
-        }
-        return retVal;
-    }
-
-    constructor() {
-        super();
-    }
-
-    toDDL(): DDL2.ISort {
-        return {
-            type: "sort",
-            conditions: this.conditions()
-        };
-    }
-
-    fromDDL(ddl: DDL2.ISort): this {
-        this.conditions(ddl.conditions);
-        return this;
-    }
-
-    static fromDDL(ddl: DDL2.ISort) {
-        return new Sort().fromDDL(ddl);
-    }
-
-    conditions(): DDL2.ISortCondition[];
-    conditions(_: DDL2.ISortCondition[]): this;
-    conditions(_?: DDL2.ISortCondition[]): DDL2.ISortCondition[] | this {
-        if (!arguments.length) return this.validSortBy().map(column => column.toDDL());
-        this.column(_.map(condition => SortColumn.fromDDL(condition)));
-        return this;
-    }
-
-    //  Activitiy  ---
-    hash(): string {
-        return hashSum({
-            Sort: this.column().map(sb => sb.hash())
-        });
-    }
-
-    referencedFields(refs: ReferencedFields): void {
-        super.referencedFields(refs);
-        super.resolveInFields(refs, this.validSortBy().map(sortBy => sortBy.fieldID()));
-    }
-
-    validSortBy(): SortColumn[] {
-        return this.column().filter(sortBy => sortBy.fieldID());
-    }
-
-    exists(): boolean {
-        return this.validSortBy().length > 0;
-    }
-
-    fieldIDs(): string[] {
-        return this.inFields().map(field => field.id);
-    }
-
-    computeData(): ReadonlyArray<object> {
-        const data = super.computeData();
-        const sortByArr: Array<{ compare: (l, r) => number, id: string }> = [];
-        for (const sortBy of this.validSortBy()) {
-            sortByArr.push({
-                compare: sortBy.descending() ? d3Descending : d3Ascending,
-                id: sortBy.fieldID()
-            });
-        }
-
-        if (sortByArr.length) {
-            return [...data].sort((l: any, r: any) => {
-                for (const item of sortByArr) {
-                    const retVal2 = item.compare(l[item.id], r[item.id]);
-                    if (retVal2 !== 0) {
-                        return retVal2;
-                    }
-                }
-                return 0;
-            });
-
-        }
-        return data;
-    }
-}
-Sort.prototype._class += " Sort";
+import { PropertyExt, publish } from "@hpcc-js/common";
+import { DDL2 } from "@hpcc-js/ddl-shim";
+import { hashSum } from "@hpcc-js/util";
+import { ascending as d3Ascending, descending as d3Descending } from "d3-array";
+import { Activity, IActivityError, ReferencedFields } from "./activity";
+
+export class SortColumn extends PropertyExt {
+    private _owner: Sort;
+
+    @publish(null, "set", "Sort Field", function (this: SortColumn) { return this.fieldIDs(); }, {
+        optional: true,
+        validate: (w: SortColumn): boolean => w.fieldIDs().indexOf(w.fieldID()) >= 0
+    })
+    fieldID: publish<this, string>;
+    fieldID_valid: () => boolean;
+    @publish(false, "boolean", "Sort Field")
+    descending: publish<this, boolean>;
+
+    validate(prefix: string): IActivityError[] {
+        const retVal: IActivityError[] = [];
+        if (!this.fieldID_valid()) {
+            retVal.push({
+                source: `${prefix}.fieldID`,
+                msg: `Invalid fieldID:  ${this.fieldID()}`,
+                hint: `expected ${JSON.stringify(this.fieldIDs())}`
+            });
+        }
+        return retVal;
+    }
+
+    constructor() {
+        super();
+    }
+
+    owner(): Sort;
+    owner(_: Sort): this;
+    owner(_?: Sort): Sort | this {
+        if (!arguments.length) return this._owner;
+        this._owner = _;
+        return this;
+    }
+
+    valid(): boolean {
+        return !!this.fieldID();
+    }
+
+    toDDL(): DDL2.ISortCondition {
+        return {
+            fieldID: this.fieldID(),
+            descending: this.descending()
+        };
+    }
+
+    fromDDL(ddl: DDL2.ISortCondition): this {
+        return this
+            .fieldID(ddl.fieldID)
+            .descending(ddl.descending)
+            ;
+    }
+
+    static fromDDL(ddl: DDL2.ISortCondition): SortColumn {
+        return new SortColumn().fromDDL(ddl);
+    }
+
+    hash(): string {
+        return hashSum({
+            sortColumn: this.fieldID(),
+            descending: this.descending()
+        });
+    }
+
+    fieldIDs() {
+        return this._owner.fieldIDs();
+    }
+
+    field(id: string): DDL2.IField | undefined {
+        return this._owner.inFields().filter(field =>
+            field.id === id
+        )[0];
+    }
+}
+SortColumn.prototype._class += " SortColumn";
+
+//  ===========================================================================
+export class Sort extends Activity {
+    static Column = SortColumn;
+
+    @publish([], "propertyArray", "Source Columns", null, { autoExpand: SortColumn })
+    column: publish<this, SortColumn[]>;
+
+    validate(): IActivityError[] {
+        let retVal: IActivityError[] = [];
+        for (const sb of this.validSortBy()) {
+            retVal = retVal.concat(sb.validate("Sort.column"));
+        }
+        return retVal;
+    }
+
+    constructor() {
+        super();
+    }
+
+    toDDL(): DDL2.ISort {
+        return {
+            type: "sort",
+            conditions: this.conditions()
+        };
+    }
+
+    fromDDL(ddl: DDL2.ISort): this {
+        this.conditions(ddl.conditions);
+        return this;
+    }
+
+    static fromDDL(ddl: DDL2.ISort) {
+        return new Sort().fromDDL(ddl);
+    }
+
+    conditions(): DDL2.ISortCondition[];
+    conditions(_: DDL2.ISortCondition[]): this;
+    conditions(_?: DDL2.ISortCondition[]): DDL2.ISortCondition[] | this {
+        if (!arguments.length) return this.validSortBy().map(column => column.toDDL());
+        this.column(_.map(condition => SortColumn.fromDDL(condition)));
+        return this;
+    }
+
+    //  Activitiy  ---
+    hash(): string {
+        return hashSum({
+            Sort: this.column().map(sb => sb.hash())
+        });
+    }
+
+    referencedFields(refs: ReferencedFields): void {
+        super.referencedFields(refs);
+        super.resolveInFields(refs, this.validSortBy().map(sortBy => sortBy.fieldID()));
+    }
+
+    validSortBy(): SortColumn[] {
+        return this.column().filter(sortBy => sortBy.fieldID());
+    }
+
+    exists(): boolean {
+        return this.validSortBy().length > 0;
+    }
+
+    fieldIDs(): string[] {
+        return this.inFields().map(field => field.id);
+    }
+
+    computeData(): ReadonlyArray<object> {
+        const data = super.computeData();
+        const sortByArr: Array<{ compare: (l, r) => number, id: string }> = [];
+        for (const sortBy of this.validSortBy()) {
+            sortByArr.push({
+                compare: sortBy.descending() ? d3Descending : d3Ascending,
+                id: sortBy.fieldID()
+            });
+        }
+
+        if (sortByArr.length) {
+            return [...data].sort((l: any, r: any) => {
+                for (const item of sortByArr) {
+                    const retVal2 = item.compare(l[item.id], r[item.id]);
+                    if (retVal2 !== 0) {
+                        return retVal2;
+                    }
+                }
+                return 0;
+            });
+
+        }
+        return data;
+    }
+}
+Sort.prototype._class += " Sort";