@hpcc-js/marshaller 2.28.11 → 3.1.0

package/src/ddl2/activities/datasource.ts

@@ -1,12 +1,11 @@
-import { publish } from "@hpcc-js/common";
 import { DDL2 } from "@hpcc-js/ddl-shim";
-import { Activity } from "./activity";
-import { Databomb } from "./databomb";
-import { Form } from "./form";
-import { LogicalFile } from "./logicalfile";
-import { RestResult, RestService } from "./rest";
-import { RoxieResult, RoxieService } from "./roxie";
-import { WU, WUResult } from "./wuresult";
+import { Activity } from "./activity.ts";
+import { Databomb } from "./databomb.ts";
+import { Form } from "./form.ts";
+import { LogicalFile } from "./logicalfile.ts";
+import { RestResult, RestService } from "./rest.ts";
+import { RoxieResult, RoxieService } from "./roxie.ts";
+import { WU, WUResult } from "./wuresult.ts";
 
 let datasourceID = 0;
 export class Datasource extends Activity {
@@ -21,16 +20,8 @@ export type DatasourceRefType = Databomb | Form | LogicalFile | RoxieResult | WU
 export type DatasourceType = Databomb | Form | LogicalFile | RoxieService | WU | RestService;
 
 export class DatasourceRef extends Activity {
-    @publish(null, "widget", "Datasource Reference", null, { internal: true })
-    _datasource: DatasourceRefType;
-    datasource(): DatasourceRefType;
-    datasource(_: DatasourceRefType): this;
-    datasource(_?: DatasourceRefType): this | DatasourceRefType {
-        if (!arguments.length) return this._datasource;
-        this._datasource = _;
-        this.sourceActivity(_);
-        return this;
-    }
+    _origDatasource;
+    declare _datasource: DatasourceRefType;
 
     constructor() {
         super();
@@ -50,3 +41,19 @@ export class DatasourceRef extends Activity {
     }
 }
 DatasourceRef.prototype._class += " DatasourceRef";
+
+export interface DatasourceRef {
+    datasource(): DatasourceRefType;
+    datasource(_: DatasourceRefType): this;
+}
+
+DatasourceRef.prototype.publish("datasource", null, "widget", "Datasource Reference", null, { internal: true });
+
+DatasourceRef.prototype._origDatasource = DatasourceRef.prototype.datasource;
+DatasourceRef.prototype.datasource = function (this: DatasourceRef, _?) {
+    const retVal = DatasourceRef.prototype._origDatasource.apply(this, arguments);
+    if (_ !== undefined) {
+        this.sourceActivity(_);
+    }
+    return retVal;
+};

package/src/ddl2/activities/dspicker.ts

@@ -1,39 +1,23 @@
-import { publish } from "@hpcc-js/common";
 import { DDL2 } from "@hpcc-js/ddl-shim";
-import { ElementContainer } from "../model/element";
-import { ActivitySelection, IActivityError } from "./activity";
-import { Databomb, emptyDatabomb } from "./databomb";
-import { DatasourceRef, DatasourceRefType } from "./datasource";
-import { Form } from "./form";
-import { LogicalFile } from "./logicalfile";
-import { RestResult, RestResultRef } from "./rest";
-import { HipieResultRef, RoxieResult, RoxieService } from "./roxie";
-import { WUResult, WUResultRef } from "./wuresult";
+import { ElementContainer } from "../model/element.ts";
+import { ActivitySelection, IActivityError } from "./activity.ts";
+import { Databomb, emptyDatabomb } from "./databomb.ts";
+import { DatasourceRef, DatasourceRefType } from "./datasource.ts";
+import { Form } from "./form.ts";
+import { LogicalFile } from "./logicalfile.ts";
+import { RestResult, RestResultRef } from "./rest.ts";
+import { HipieResultRef, RoxieResult, RoxieService } from "./roxie.ts";
+import { WUResult, WUResultRef } from "./wuresult.ts";
 
 let dsPickerID = 0;
 export class DSPicker extends ActivitySelection {
     private _nullDatasource = emptyDatabomb;
 
-    @publish("", "set", "Activity", function (this: DSPicker) { return this.datasourceIDs(); }, { optional: false })
-    _datasourceID: string; // DDL2.IDatasourceType;
-    datasourceID(): string;
-    datasourceID(_: string): this;
-    datasourceID(_?: string): this | string {
-        if (!arguments.length) return this._datasourceID;
-        if (this._datasourceID !== _) {
-            this._datasourceID = _;
-            this.refreshRef(_);
-        }
-        return this;
-    }
+    _origDatasourceID;
+    _origDatasourceRef;
 
-    @publish("", "widget", "Activity")
-    _datasourceRef: DatasourceRef;
-    datasourceRef(): DatasourceRef;
-    datasourceRef(_: DatasourceRef): this;
-    datasourceRef(_?: DatasourceRef): this | DatasourceRef {
-        return super.selection.apply(this, arguments);
-    }
+    declare _datasourceID: string; // DDL2.IDatasourceType;
+    declare _datasourceRef: DatasourceRef;
 
     datasource(): DatasourceRefType {
         return this.datasourceRef().datasource();
@@ -104,3 +88,28 @@ export class DSPicker extends ActivitySelection {
     }
 }
 DSPicker.prototype._class += " DSPicker";
+
+export interface DSPicker {
+    datasourceID(): string;
+    datasourceID(_: string): this;
+    datasourceRef(): DatasourceRef;
+    datasourceRef(_: DatasourceRef): this;
+}
+
+DSPicker.prototype.publish("datasourceID", "", "set", "Activity", function (this: DSPicker) { return this.datasourceIDs(); }, { optional: false });
+DSPicker.prototype.publish("datasourceRef", "", "widget", "Activity");
+
+DSPicker.prototype._origDatasourceID = DSPicker.prototype.datasourceID;
+DSPicker.prototype.datasourceID = function (this: DSPicker, _?) {
+    const prev = this._datasourceID;
+    const retVal = DSPicker.prototype._origDatasourceID.apply(this, arguments);
+    if (_ !== undefined && prev !== _) {
+        this.refreshRef(_);
+    }
+    return retVal;
+};
+
+DSPicker.prototype._origDatasourceRef = DSPicker.prototype.datasourceRef;
+DSPicker.prototype.datasourceRef = function (this: DSPicker, _?) {
+    return ActivitySelection.prototype.selection.apply(this, arguments);
+};

package/src/ddl2/activities/filter.ts

@@ -1,8 +1,8 @@
-import { PropertyExt, publish } from "@hpcc-js/common";
+import { PropertyExt } from "@hpcc-js/common";
 import { DDL2 } from "@hpcc-js/ddl-shim";
 import { hashSum } from "@hpcc-js/util";
-import { Element, ElementContainer } from "../model/element";
-import { Activity, IActivityError, ReferencedFields } from "./activity";
+import { Element, ElementContainer } from "../model/element.ts";
+import { Activity, IActivityError, ReferencedFields } from "./activity.ts";
 
 function createFilter(condition: DDL2.IMappingConditionType, lf: string, val: string | number): (localRow: any) => boolean {
     const isString = typeof val === "string";
@@ -27,27 +27,6 @@ function createFilter(condition: DDL2.IMappingConditionType, lf: string, val: st
 export class ColumnMapping extends PropertyExt {
     private _owner: RemoteFilter;
 
-    @publish(null, "set", "Filter Fields", function (this: ColumnMapping) { return this.sourceOutFields(); }, {
-        optional: true,
-        disable: (w: ColumnMapping): boolean => !w._owner.source(),
-        validate: (w: ColumnMapping): boolean => w.sourceOutFields().indexOf(w.remoteField()) >= 0
-    })
-    remoteField: publish<this, string>;
-    remoteField_exists: () => boolean;
-    remoteField_valid: () => boolean;
-    @publish(null, "set", "Local Fields", function (this: ColumnMapping) { return this.localFields(); }, {
-        optional: true,
-        disable: (w: ColumnMapping): boolean => !w._owner.source(),
-        validate: (w: ColumnMapping): boolean => w.localFields().indexOf(w.localField()) >= 0
-    })
-    localField: publish<this, string>;
-    localField_exists: () => boolean;
-    localField_valid: () => boolean;
-    @publish("==", "set", "Filter Fields", ["==", "!=", ">", ">=", "<", "<=", "range", "in"])
-    condition: publish<this, DDL2.IMappingConditionType>;
-    @publish(false, "boolean", "Ignore null filters")
-    nullable: publish<this, boolean>;
-
     validate(prefix: string): IActivityError[] {
         const retVal: IActivityError[] = [];
         if (!this.remoteField_valid()) {
@@ -168,19 +147,24 @@ export class ColumnMapping extends PropertyExt {
 }
 ColumnMapping.prototype._class += " ColumnMapping";
 
+export interface ColumnMapping {
+    remoteField(): string;
+    remoteField(_: string): this;
+    remoteField_exists(): boolean;
+    remoteField_valid(): boolean;
+    localField(): string;
+    localField(_: string): this;
+    localField_exists(): boolean;
+    localField_valid(): boolean;
+    condition(): DDL2.IMappingConditionType;
+    condition(_: DDL2.IMappingConditionType): this;
+    nullable(): boolean;
+    nullable(_: boolean): this;
+}
+
 export class RemoteFilter extends PropertyExt {
     private _owner: Filters;
 
-    @publish(null, "set", "Activity", function (this: RemoteFilter) { return this.visualizationIDs(); }, {
-        optional: true,
-        validate: (w: RemoteFilter): boolean => w.visualizationIDs().indexOf(w.source()) >= 0
-    })
-    source: publish<this, string>;
-    source_exists: () => boolean;
-    source_valid: () => boolean;
-    @publish([], "propertyArray", "Mappings", null, { autoExpand: ColumnMapping })
-    mappings: publish<this, ColumnMapping[]>;
-
     validate(prefix: string): IActivityError[] {
         let retVal: IActivityError[] = [];
         if (!this.source_valid()) {
@@ -303,25 +287,18 @@ export class RemoteFilter extends PropertyExt {
 }
 RemoteFilter.prototype._class += " Filter";
 
+export interface RemoteFilter {
+    source(): string;
+    source(_: string): this;
+    source_exists(): boolean;
+    source_valid(): boolean;
+    mappings(): ColumnMapping[];
+    mappings(_: ColumnMapping[]): this;
+}
+
 export class StaticFilter extends PropertyExt {
     private _owner: Filters;
 
-    @publish(null, "set", "Local Fields", function (this: ColumnMapping) { return this.localFields(); }, {
-        optional: true,
-        validate: (w: StaticFilter): boolean => w.localFields().indexOf(w.localField()) >= 0
-    })
-    localField: publish<this, string>;
-    localField_exists: () => boolean;
-    localField_valid: () => boolean;
-    @publish("==", "set", "Filter Fields", ["==", "!=", ">", ">=", "<", "<="])
-    condition: publish<this, DDL2.IMappingConditionType>;
-    @publish("", "any", "Static Value")
-    value: publish<this, string | number | boolean>;
-    value_exists: () => boolean;
-    value_valid: () => boolean;
-    @publish("number", "set", "Static Value Type", ["number", "string"])
-    valueType: publish<this, "number" | "string">;
-
     validate(prefix: string): IActivityError[] {
         const retVal: IActivityError[] = [];
         if (!this.localField_valid()) {
@@ -414,18 +391,27 @@ export class StaticFilter extends PropertyExt {
 }
 StaticFilter.prototype._class += " StaticFilter";
 
+export interface StaticFilter {
+    localField(): string;
+    localField(_: string): this;
+    localField_exists(): boolean;
+    localField_valid(): boolean;
+    condition(): DDL2.IMappingConditionType;
+    condition(_: DDL2.IMappingConditionType): this;
+    value(): string | number | boolean;
+    value(_: string | number | boolean): this;
+    value_exists(): boolean;
+    value_valid(): boolean;
+    valueType(): "number" | "string";
+    valueType(_: "number" | "string"): this;
+}
+
 type FilterT = RemoteFilter | StaticFilter;
 
 export class Filters extends Activity {
     static Filter = RemoteFilter;
     static Mapping = ColumnMapping;
 
-    @publish([], "propertyArray", "Remote Filter", null, { autoExpand: RemoteFilter })
-    remoteFilter: publish<this, RemoteFilter[]>;
-
-    @publish([], "propertyArray", "Static Filter", null, { autoExpand: StaticFilter })
-    staticFilter: publish<this, StaticFilter[]>;
-
     validate(): IActivityError[] {
         let retVal: IActivityError[] = [];
         for (const filter of this.validFilters()) {
@@ -540,3 +526,40 @@ export class Filters extends Activity {
     }
 }
 Filters.prototype._class += " Filters";
+
+export interface Filters {
+    remoteFilter(): RemoteFilter[];
+    remoteFilter(_: RemoteFilter[]): this;
+    staticFilter(): StaticFilter[];
+    staticFilter(_: StaticFilter[]): this;
+}
+
+ColumnMapping.prototype.publish("remoteField", null, "set", "Filter Fields", function (this: ColumnMapping) { return this.sourceOutFields(); }, {
+    optional: true,
+    disable: (w: ColumnMapping): boolean => !w["_owner"].source(),
+    validate: (w: ColumnMapping): boolean => w.sourceOutFields().indexOf(w.remoteField()) >= 0
+});
+ColumnMapping.prototype.publish("localField", null, "set", "Local Fields", function (this: ColumnMapping) { return this.localFields(); }, {
+    optional: true,
+    disable: (w: ColumnMapping): boolean => !w["_owner"].source(),
+    validate: (w: ColumnMapping): boolean => w.localFields().indexOf(w.localField()) >= 0
+});
+ColumnMapping.prototype.publish("condition", "==", "set", "Filter Fields", ["==", "!=", ">", ">=", "<", "<=", "range", "in"]);
+ColumnMapping.prototype.publish("nullable", false, "boolean", "Ignore null filters");
+
+RemoteFilter.prototype.publish("source", null, "set", "Activity", function (this: RemoteFilter) { return this.visualizationIDs(); }, {
+    optional: true,
+    validate: (w: RemoteFilter): boolean => w.visualizationIDs().indexOf(w.source()) >= 0
+});
+RemoteFilter.prototype.publish("mappings", [], "propertyArray", "Mappings", null, { autoExpand: ColumnMapping });
+
+StaticFilter.prototype.publish("localField", null, "set", "Local Fields", function (this: ColumnMapping) { return this.localFields(); }, {
+    optional: true,
+    validate: (w: StaticFilter): boolean => w.localFields().indexOf(w.localField()) >= 0
+});
+StaticFilter.prototype.publish("condition", "==", "set", "Filter Fields", ["==", "!=", ">", ">=", "<", "<="]);
+StaticFilter.prototype.publish("value", "", "any", "Static Value");
+StaticFilter.prototype.publish("valueType", "number", "set", "Static Value Type", ["number", "string"]);
+
+Filters.prototype.publish("remoteFilter", [], "propertyArray", "Remote Filter", null, { autoExpand: RemoteFilter });
+Filters.prototype.publish("staticFilter", [], "propertyArray", "Static Filter", null, { autoExpand: StaticFilter });

package/src/ddl2/activities/form.ts

@@ -1,28 +1,12 @@
-import { PropertyExt, publish } from "@hpcc-js/common";
+import { PropertyExt } from "@hpcc-js/common";
 import { DDL2 } from "@hpcc-js/ddl-shim";
-import { Datasource } from "./datasource";
+import { Datasource } from "./datasource.ts";
 
 type IField = DDL2.IFieldBoolean | DDL2.IFieldNumber | DDL2.IFieldString | DDL2.IFieldDataset;
 
 export class FormField extends PropertyExt {
     protected _owner: Form;
 
-    @publish("", "string", "FormField Label")
-    fieldID: publish<this, string>;
-
-    @publish("string", "set", "FormField Type", ["boolean", "number", "string", "dataset"])
-    type: publish<this, "boolean" | "number" | "string" | "dataset">;
-
-    @publish(null, "any", "Default Value", null, { optional: true })
-    default: publish<this, boolean | number | string | any[]>;
-
-    @publish(null, "any", "Default Value", null, { optional: true })
-    value: publish<this, boolean | number | string>;
-    value_exists: () => boolean;
-
-    @publish([], "propertyArray", "Child Fields", null, { autoExpand: FormField, disable: (w: FormField) => w.disableChildField() })
-    childFields: publish<this, FormField[]>;
-
     disableChildField(): boolean {
         return this.type() !== "dataset";
     }
@@ -83,8 +67,6 @@ export class FormField extends PropertyExt {
 }
 
 export class Form extends Datasource {
-    @publish([], "propertyArray", "Multi Fields", null, { autoExpand: FormField })
-    formFields: publish<this, FormField[]>;
 
     constructor() {
         super();
@@ -151,3 +133,30 @@ export class Form extends Datasource {
     }
 }
 Form.prototype._class += " Form";
+
+export interface FormField {
+    type(): "boolean" | "number" | "string" | "dataset";
+    type(_: "boolean" | "number" | "string" | "dataset"): this;
+    fieldID(): string;
+    fieldID(_: string): this;
+    default(): boolean | number | string | any[];
+    default(_: boolean | number | string | any[]): this;
+    value(): boolean | number | string;
+    value(_: boolean | number | string): this;
+    value_exists(): boolean;
+    childFields(): FormField[];
+    childFields(_: FormField[]): this;
+}
+
+export interface Form {
+    formFields(): FormField[];
+    formFields(_: FormField[]): this;
+}
+
+FormField.prototype.publish("type", "string", "set", "FormField Type", ["boolean", "number", "string", "dataset"]);
+FormField.prototype.publish("fieldID", "", "string", "FormField Label");
+FormField.prototype.publish("default", null, "any", "Default Value", null, { optional: true });
+FormField.prototype.publish("value", null, "any", "Default Value", null, { optional: true });
+FormField.prototype.publish("childFields", [], "propertyArray", "Child Fields", null, { autoExpand: FormField, disable: (w: FormField) => w.disableChildField() });
+
+Form.prototype.publish("formFields", [], "propertyArray", "Multi Fields", null, { autoExpand: FormField });

package/src/ddl2/activities/groupby.ts

@@ -1,20 +1,13 @@
-import { PropertyExt, publish } from "@hpcc-js/common";
+import { PropertyExt } from "@hpcc-js/common";
 import { DDL2 } from "@hpcc-js/ddl-shim";
 import { hashSum } from "@hpcc-js/util";
 import { deviation as d3Deviation, max as d3Max, mean as d3Mean, median as d3Median, min as d3Min, sum as d3Sum, variance as d3Variance } from "d3-array";
 import { nest as d3Nest } from "d3-collection";
-import { Activity, IActivityError, ReferencedFields } from "./activity";
+import { Activity, IActivityError, ReferencedFields } from "./activity.ts";
 
 export class GroupByColumn extends PropertyExt {
     private _owner: GroupBy;
 
-    @publish(undefined, "set", "Field", function (this: GroupByColumn) { return this.columns(); }, {
-        optional: true,
-        validate: (w: GroupByColumn): boolean => w.columns().indexOf(w.label()) >= 0
-    })
-    label: publish<this, string>;
-    label_valid: () => boolean;
-
     validate(prefix: string): IActivityError[] {
         const retVal: IActivityError[] = [];
         if (!this.label_valid()) {
@@ -67,6 +60,12 @@ export class GroupByColumn extends PropertyExt {
 }
 GroupByColumn.prototype._class += " GroupByColumn";
 
+export interface GroupByColumn {
+    label(): string;
+    label(_: string): this;
+    label_valid(): boolean;
+}
+
 //  ===========================================================================
 export type AggrFuncCallback = (item: any) => number;
 export type AggrFunc = (leaves: any[], callback: AggrFuncCallback) => number;
@@ -89,25 +88,6 @@ export type AggregateType = "count" | "min" | "max" | "sum" | "mean" | "median"
 export class AggregateField extends PropertyExt {
     private _owner: GroupBy;
 
-    @publish(null, "string", "new Field ID", null, { optional: true, disable: (w: AggregateField) => !w.hasColumn() })
-    fieldID: publish<this, string>;
-    @publish("count", "set", "Aggregation Type", ["count", "min", "max", "sum", "mean", "median", "variance", "deviation"], { optional: true, disable: (w: AggregateField) => !w.fieldID() })
-    aggrType: publish<this, AggregateType>;
-    @publish(null, "set", "Aggregation Field", function (this: AggregateField) { return this.columns(); }, {
-        optional: true,
-        disable: (w: AggregateField) => w.disableAggrColumn(),
-        validate: (w: AggregateField): boolean => w.columns().indexOf(w.aggrColumn()) >= 0
-    })
-    aggrColumn: publish<this, string>;
-    aggrColumn_valid: () => boolean;
-    @publish(null, "set", "Base Count Field", function (this: AggregateField) { return this.columns(); }, {
-        optional: true,
-        disable: (w: AggregateField) => w.disableBaseCountColumn(),
-        validate: (w: AggregateField): boolean => w.columns().indexOf(w.baseCountColumn()) >= 0
-    })
-    baseCountColumn: publish<this, string>;
-    baseCountColumn_valid: () => boolean;
-
     disableAggrColumn(): boolean {
         return !this.fieldID() || !this.aggrType() || this.aggrType() === "count";
     }
@@ -219,18 +199,22 @@ export class AggregateField extends PropertyExt {
 }
 AggregateField.prototype._class += " AggregateField";
 
+export interface AggregateField {
+    fieldID(): string;
+    fieldID(_: string): this;
+    aggrType(): AggregateType;
+    aggrType(_: AggregateType): this;
+    aggrColumn(): string;
+    aggrColumn(_: string): this;
+    aggrColumn_valid(): boolean;
+    baseCountColumn(): string;
+    baseCountColumn(_: string): this;
+    baseCountColumn_valid(): boolean;
+}
+
 //  ===========================================================================
 export class GroupBy extends Activity {
 
-    @publish([], "propertyArray", "Source Columns", null, { autoExpand: GroupByColumn })
-    column: publish<this, GroupByColumn[]>;
-    @publish([], "propertyArray", "Computed Fields", null, { autoExpand: AggregateField })
-    computedFields: publish<this, AggregateField[]>;
-    @publish(false, "boolean", "Show details")
-    details: publish<this, boolean>;
-    @publish(false, "boolean", "Show groupBy fileds in details")
-    fullDetails: publish<this, boolean>;
-
     validate(): IActivityError[] {
         let retVal: IActivityError[] = [];
         for (const gbColumn of this.validGroupBy()) {
@@ -437,3 +421,37 @@ export class GroupBy extends Activity {
     }
 }
 GroupBy.prototype._class += " GroupBy";
+
+export interface GroupBy {
+    column(): GroupByColumn[];
+    column(_: GroupByColumn[]): this;
+    computedFields(): AggregateField[];
+    computedFields(_: AggregateField[]): this;
+    details(): boolean;
+    details(_: boolean): this;
+    fullDetails(): boolean;
+    fullDetails(_: boolean): this;
+}
+
+GroupByColumn.prototype.publish("label", undefined, "set", "Field", function (this: GroupByColumn) { return this.columns(); }, {
+        optional: true,
+        validate: (w: GroupByColumn): boolean => w.columns().indexOf(w.label()) >= 0
+    });
+
+AggregateField.prototype.publish("fieldID", null, "string", "new Field ID", null, { optional: true, disable: (w: AggregateField) => !w.hasColumn() });
+AggregateField.prototype.publish("aggrType", "count", "set", "Aggregation Type", ["count", "min", "max", "sum", "mean", "median", "variance", "deviation"], { optional: true, disable: (w: AggregateField) => !w.fieldID() });
+AggregateField.prototype.publish("aggrColumn", null, "set", "Aggregation Field", function (this: AggregateField) { return this.columns(); }, {
+        optional: true,
+        disable: (w: AggregateField) => w.disableAggrColumn(),
+        validate: (w: AggregateField): boolean => w.columns().indexOf(w.aggrColumn()) >= 0
+    });
+AggregateField.prototype.publish("baseCountColumn", null, "set", "Base Count Field", function (this: AggregateField) { return this.columns(); }, {
+        optional: true,
+        disable: (w: AggregateField) => w.disableBaseCountColumn(),
+        validate: (w: AggregateField): boolean => w.columns().indexOf(w.baseCountColumn()) >= 0
+    });
+
+GroupBy.prototype.publish("column", [], "propertyArray", "Source Columns", null, { autoExpand: GroupByColumn });
+GroupBy.prototype.publish("computedFields", [], "propertyArray", "Computed Fields", null, { autoExpand: AggregateField });
+GroupBy.prototype.publish("details", false, "boolean", "Show details");
+GroupBy.prototype.publish("fullDetails", false, "boolean", "Show groupBy fileds in details");

package/src/ddl2/activities/hipiepipeline.ts

@@ -1,82 +1,29 @@
-import { publish } from "@hpcc-js/common";
 import { DDL2 } from "@hpcc-js/ddl-shim";
-import { ElementContainer } from "../model/element";
-import { Activity, ActivityPipeline } from "./activity";
-import { DatasourceRefType } from "./datasource";
-import { DSPicker } from "./dspicker";
-import { Filters } from "./filter";
-import { GroupBy } from "./groupby";
-import { Limit } from "./limit";
-import { Project } from "./project";
-import { Sort } from "./sort";
+import { ElementContainer } from "../model/element.ts";
+import { Activity, ActivityPipeline } from "./activity.ts";
+import { DatasourceRefType } from "./datasource.ts";
+import { DSPicker } from "./dspicker.ts";
+import { Filters } from "./filter.ts";
+import { GroupBy } from "./groupby.ts";
+import { Limit } from "./limit.ts";
+import { Project } from "./project.ts";
+import { Sort } from "./sort.ts";
 
 export class HipiePipeline extends ActivityPipeline {
 
-    @publish(null, "widget", "Data Source 2")
-    _datasource: DSPicker | DatasourceRefType;
-    datasource(): DSPicker | DatasourceRefType;
-    datasource(_: DSPicker | DatasourceRefType): this;
-    datasource(_?: DSPicker | DatasourceRefType): DSPicker | DatasourceRefType | this {
-        if (!arguments.length) return this._datasource;
-        this._datasource = _;
-        this.updateSequence();
-        return this;
-    }
-
-    @publish(null, "widget", "Client Filters")
-    _filters: Filters;
-    filters(): Filters;
-    filters(_: Filters): this;
-    filters(_?: Filters): Filters | this {
-        if (!arguments.length) return this._filters;
-        this._filters = _;
-        this.updateSequence();
-        return this;
-    }
-
-    @publish(null, "widget", "Project")
-    _project: Project;
-    project(): Project;
-    project(_: Project): this;
-    project(_?: Project): Project | this {
-        if (!arguments.length) return this._project;
-        this._project = _;
-        this.updateSequence();
-        return this;
-    }
-
-    @publish(null, "widget", "Group By")
-    _groupBy: GroupBy;
-    groupBy(): GroupBy;
-    groupBy(_: GroupBy): this;
-    groupBy(_?: GroupBy): GroupBy | this {
-        if (!arguments.length) return this._groupBy;
-        this._groupBy = _;
-        this.updateSequence();
-        return this;
-    }
-
-    @publish(null, "widget", "Sort")
-    _sort: Sort;
-    sort(): Sort;
-    sort(_: Sort): this;
-    sort(_?: Sort): Sort | this {
-        if (!arguments.length) return this._sort;
-        this._sort = _;
-        this.updateSequence();
-        return this;
-    }
+    _origDatasource;
+    _origFilters;
+    _origProject;
+    _origGroupBy;
+    _origSort;
+    _origLimit;
 
-    @publish(null, "widget", "Limit output")
-    _limit: Limit;
-    limit(): Limit;
-    limit(_: Limit): this;
-    limit(_?: Limit): Limit | this {
-        if (!arguments.length) return this._limit;
-        this._limit = _;
-        this.updateSequence();
-        return this;
-    }
+    declare _datasource: DSPicker | DatasourceRefType;
+    declare _filters: Filters;
+    declare _project: Project;
+    declare _groupBy: GroupBy;
+    declare _sort: Sort;
+    declare _limit: Limit;
 
     constructor(private _ec: ElementContainer, viewID: string) {
         super();
@@ -112,3 +59,43 @@ export class HipiePipeline extends ActivityPipeline {
         return this.last().outFields();
     }
 }
+
+export interface HipiePipeline {
+    datasource(): DSPicker | DatasourceRefType;
+    datasource(_: DSPicker | DatasourceRefType): this;
+    filters(): Filters;
+    filters(_: Filters): this;
+    project(): Project;
+    project(_: Project): this;
+    groupBy(): GroupBy;
+    groupBy(_: GroupBy): this;
+    sort(): Sort;
+    sort(_: Sort): this;
+    limit(): Limit;
+    limit(_: Limit): this;
+}
+
+HipiePipeline.prototype.publish("datasource", null, "widget", "Data Source 2");
+HipiePipeline.prototype.publish("filters", null, "widget", "Client Filters");
+HipiePipeline.prototype.publish("project", null, "widget", "Project");
+HipiePipeline.prototype.publish("groupBy", null, "widget", "Group By");
+HipiePipeline.prototype.publish("sort", null, "widget", "Sort");
+HipiePipeline.prototype.publish("limit", null, "widget", "Limit output");
+
+function wrapHipiePipelineProperty(prop: string) {
+    const origKey = `_orig${prop.charAt(0).toUpperCase() + prop.slice(1)}`;
+    HipiePipeline.prototype[origKey] = HipiePipeline.prototype[prop];
+    HipiePipeline.prototype[prop] = function (_?) {
+        const retVal = HipiePipeline.prototype[origKey].apply(this, arguments);
+        if (_ !== undefined) {
+            this.updateSequence();
+        }
+        return retVal;
+    };
+}
+wrapHipiePipelineProperty("datasource");
+wrapHipiePipelineProperty("filters");
+wrapHipiePipelineProperty("project");
+wrapHipiePipelineProperty("groupBy");
+wrapHipiePipelineProperty("sort");
+wrapHipiePipelineProperty("limit");