@hpcc-js/ddl-shim 2.22.0 → 2.24.0

package/dist/cli.js

@@ -1,2656 +0,0 @@
-#!/usr/bin/env node
-
-'use strict';
-
-var fs = require('fs');
-
-function _interopNamespaceDefault(e) {
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
-
-var $ref = "#/definitions/Schema";
-var $schema = "http://json-schema.org/draft-07/schema#";
-var definitions = {
-	ActivityType: {
-		anyOf: [
-			{
-				$ref: "#/definitions/IFilter"
-			},
-			{
-				$ref: "#/definitions/IProject"
-			},
-			{
-				$ref: "#/definitions/IGroupBy"
-			},
-			{
-				$ref: "#/definitions/ISort"
-			},
-			{
-				$ref: "#/definitions/ILimit"
-			},
-			{
-				$ref: "#/definitions/IMappings"
-			}
-		]
-	},
-	AggregateType: {
-		anyOf: [
-			{
-				$ref: "#/definitions/IAggregate"
-			},
-			{
-				$ref: "#/definitions/ICount"
-			}
-		]
-	},
-	Dataset: {
-		items: {
-		},
-		type: "array"
-	},
-	DatasourceType: {
-		anyOf: [
-			{
-				$ref: "#/definitions/IWUResult"
-			},
-			{
-				$ref: "#/definitions/ILogicalFile"
-			},
-			{
-				$ref: "#/definitions/IRoxieService"
-			},
-			{
-				$ref: "#/definitions/IHipieService"
-			},
-			{
-				$ref: "#/definitions/IRestService"
-			},
-			{
-				$ref: "#/definitions/IForm"
-			},
-			{
-				$ref: "#/definitions/IDatabomb"
-			}
-		]
-	},
-	FilterCondition: {
-		anyOf: [
-			{
-				$ref: "#/definitions/IFilterCondition"
-			},
-			{
-				$ref: "#/definitions/IFilterStaticCondition"
-			}
-		]
-	},
-	IAggregate: {
-		additionalProperties: false,
-		properties: {
-			baseCountFieldID: {
-				type: "string"
-			},
-			fieldID: {
-				type: "string"
-			},
-			inFieldID: {
-				type: "string"
-			},
-			type: {
-				$ref: "#/definitions/IAggregateType"
-			}
-		},
-		required: [
-			"fieldID",
-			"type",
-			"inFieldID"
-		],
-		type: "object"
-	},
-	IAggregateType: {
-		"enum": [
-			"min",
-			"max",
-			"sum",
-			"mean",
-			"variance",
-			"deviation"
-		],
-		type: "string"
-	},
-	ICalculated: {
-		additionalProperties: false,
-		properties: {
-			fieldID: {
-				type: "string"
-			},
-			sourceFieldID1: {
-				type: "string"
-			},
-			sourceFieldID2: {
-				type: "string"
-			},
-			type: {
-				$ref: "#/definitions/ICalculatedType"
-			}
-		},
-		required: [
-			"fieldID",
-			"type",
-			"sourceFieldID1",
-			"sourceFieldID2"
-		],
-		type: "object"
-	},
-	ICalculatedType: {
-		"enum": [
-			"+",
-			"-",
-			"*",
-			"/"
-		],
-		type: "string"
-	},
-	ICount: {
-		additionalProperties: false,
-		properties: {
-			fieldID: {
-				type: "string"
-			},
-			type: {
-				"const": "count",
-				type: "string"
-			}
-		},
-		required: [
-			"fieldID",
-			"type"
-		],
-		type: "object"
-	},
-	IDatabomb: {
-		additionalProperties: false,
-		properties: {
-			fields: {
-				items: {
-					$ref: "#/definitions/IField"
-				},
-				type: "array"
-			},
-			format: {
-				$ref: "#/definitions/IDatabombFormat"
-			},
-			id: {
-				type: "string"
-			},
-			payload: {
-				type: "string"
-			},
-			type: {
-				"const": "databomb",
-				type: "string"
-			}
-		},
-		required: [
-			"fields",
-			"format",
-			"id",
-			"type"
-		],
-		type: "object"
-	},
-	IDatabombFormat: {
-		"enum": [
-			"csv",
-			"tsv",
-			"json"
-		],
-		type: "string"
-	},
-	IDatabombRef: {
-		additionalProperties: false,
-		properties: {
-			id: {
-				type: "string"
-			}
-		},
-		required: [
-			"id"
-		],
-		type: "object"
-	},
-	IDatasource: {
-		additionalProperties: false,
-		properties: {
-			id: {
-				type: "string"
-			},
-			type: {
-				$ref: "#/definitions/IDatasourceType"
-			}
-		},
-		required: [
-			"type",
-			"id"
-		],
-		type: "object"
-	},
-	IDatasourceRef: {
-		anyOf: [
-			{
-				$ref: "#/definitions/IDatabombRef"
-			},
-			{
-				$ref: "#/definitions/IWUResultRef"
-			},
-			{
-				$ref: "#/definitions/IRoxieServiceRef"
-			},
-			{
-				$ref: "#/definitions/IHipieSqlRef"
-			}
-		]
-	},
-	IDatasourceType: {
-		"enum": [
-			"wuresult",
-			"logicalfile",
-			"roxie",
-			"hipie",
-			"rest",
-			"form",
-			"databomb"
-		],
-		type: "string"
-	},
-	IEquals: {
-		additionalProperties: false,
-		properties: {
-			fieldID: {
-				type: "string"
-			},
-			sourceFieldID: {
-				type: "string"
-			},
-			transformations: {
-				items: {
-					$ref: "#/definitions/MultiTransformationType"
-				},
-				type: "array"
-			},
-			type: {
-				"const": "=",
-				type: "string"
-			}
-		},
-		required: [
-			"fieldID",
-			"type",
-			"sourceFieldID"
-		],
-		type: "object"
-	},
-	IField: {
-		anyOf: [
-			{
-				$ref: "#/definitions/IFieldBoolean"
-			},
-			{
-				$ref: "#/definitions/IFieldNumber"
-			},
-			{
-				$ref: "#/definitions/IFieldNumber64"
-			},
-			{
-				$ref: "#/definitions/IFieldString"
-			},
-			{
-				$ref: "#/definitions/IFieldRange"
-			},
-			{
-				$ref: "#/definitions/IFieldDataset"
-			},
-			{
-				$ref: "#/definitions/IFieldSet"
-			},
-			{
-				$ref: "#/definitions/IFieldObject"
-			}
-		]
-	},
-	IFieldBoolean: {
-		additionalProperties: false,
-		properties: {
-			"default": {
-				type: "boolean"
-			},
-			id: {
-				type: "string"
-			},
-			type: {
-				"const": "boolean",
-				type: "string"
-			}
-		},
-		required: [
-			"type",
-			"id"
-		],
-		type: "object"
-	},
-	IFieldDataset: {
-		additionalProperties: false,
-		properties: {
-			children: {
-				items: {
-					$ref: "#/definitions/IField"
-				},
-				type: "array"
-			},
-			"default": {
-				$ref: "#/definitions/Dataset"
-			},
-			id: {
-				type: "string"
-			},
-			type: {
-				"const": "dataset",
-				type: "string"
-			}
-		},
-		required: [
-			"type",
-			"id",
-			"children"
-		],
-		type: "object"
-	},
-	IFieldNumber: {
-		additionalProperties: false,
-		properties: {
-			"default": {
-				type: "number"
-			},
-			id: {
-				type: "string"
-			},
-			type: {
-				"const": "number",
-				type: "string"
-			}
-		},
-		required: [
-			"type",
-			"id"
-		],
-		type: "object"
-	},
-	IFieldNumber64: {
-		additionalProperties: false,
-		properties: {
-			"default": {
-				$ref: "#/definitions/Number64"
-			},
-			id: {
-				type: "string"
-			},
-			type: {
-				"const": "number64",
-				type: "string"
-			}
-		},
-		required: [
-			"type",
-			"id"
-		],
-		type: "object"
-	},
-	IFieldObject: {
-		additionalProperties: false,
-		properties: {
-			"default": {
-				type: "object"
-			},
-			fields: {
-				additionalProperties: {
-					$ref: "#/definitions/IField"
-				},
-				type: "object"
-			},
-			id: {
-				type: "string"
-			},
-			type: {
-				"const": "object",
-				type: "string"
-			}
-		},
-		required: [
-			"type",
-			"id",
-			"fields"
-		],
-		type: "object"
-	},
-	IFieldRange: {
-		additionalProperties: false,
-		properties: {
-			"default": {
-				$ref: "#/definitions/Range"
-			},
-			id: {
-				type: "string"
-			},
-			type: {
-				"const": "range",
-				type: "string"
-			}
-		},
-		required: [
-			"type",
-			"id"
-		],
-		type: "object"
-	},
-	IFieldSet: {
-		additionalProperties: false,
-		properties: {
-			"default": {
-				items: {
-					type: [
-						"string",
-						"number"
-					]
-				},
-				type: "array"
-			},
-			fieldType: {
-				"enum": [
-					"string",
-					"number"
-				],
-				type: "string"
-			},
-			id: {
-				type: "string"
-			},
-			type: {
-				"const": "set",
-				type: "string"
-			}
-		},
-		required: [
-			"type",
-			"id",
-			"fieldType"
-		],
-		type: "object"
-	},
-	IFieldString: {
-		additionalProperties: false,
-		properties: {
-			"default": {
-				type: "string"
-			},
-			id: {
-				type: "string"
-			},
-			type: {
-				"const": "string",
-				type: "string"
-			}
-		},
-		required: [
-			"type",
-			"id"
-		],
-		type: "object"
-	},
-	IFieldType: {
-		"enum": [
-			"boolean",
-			"number",
-			"number64",
-			"string",
-			"range",
-			"dataset",
-			"set",
-			"object"
-		],
-		type: "string"
-	},
-	IFilter: {
-		additionalProperties: false,
-		properties: {
-			conditions: {
-				items: {
-					$ref: "#/definitions/FilterCondition"
-				},
-				type: "array"
-			},
-			type: {
-				"const": "filter",
-				type: "string"
-			}
-		},
-		required: [
-			"conditions",
-			"type"
-		],
-		type: "object"
-	},
-	IFilterCondition: {
-		additionalProperties: false,
-		properties: {
-			mappings: {
-				items: {
-					$ref: "#/definitions/IMapping"
-				},
-				type: "array"
-			},
-			viewID: {
-				type: "string"
-			}
-		},
-		required: [
-			"viewID",
-			"mappings"
-		],
-		type: "object"
-	},
-	IFilterStaticCondition: {
-		additionalProperties: false,
-		properties: {
-			condition: {
-				$ref: "#/definitions/IMappingConditionType"
-			},
-			localFieldID: {
-				type: "string"
-			},
-			value: {
-				type: [
-					"string",
-					"number"
-				]
-			}
-		},
-		required: [
-			"localFieldID",
-			"condition",
-			"value"
-		],
-		type: "object"
-	},
-	IForm: {
-		additionalProperties: false,
-		properties: {
-			fields: {
-				items: {
-					$ref: "#/definitions/IField"
-				},
-				type: "array"
-			},
-			id: {
-				type: "string"
-			},
-			type: {
-				"const": "form",
-				type: "string"
-			}
-		},
-		required: [
-			"fields",
-			"id",
-			"type"
-		],
-		type: "object"
-	},
-	IGroupBy: {
-		additionalProperties: false,
-		properties: {
-			aggregates: {
-				items: {
-					$ref: "#/definitions/AggregateType"
-				},
-				type: "array"
-			},
-			groupByIDs: {
-				items: {
-					type: "string"
-				},
-				type: "array"
-			},
-			type: {
-				"const": "groupby",
-				type: "string"
-			}
-		},
-		required: [
-			"aggregates",
-			"groupByIDs",
-			"type"
-		],
-		type: "object"
-	},
-	IHipieService: {
-		additionalProperties: false,
-		properties: {
-			id: {
-				type: "string"
-			},
-			inputs: {
-				items: {
-					$ref: "#/definitions/IField"
-				},
-				type: "array"
-			},
-			outputs: {
-				$ref: "#/definitions/OutputDict"
-			},
-			queryID: {
-				type: "string"
-			},
-			querySet: {
-				type: "string"
-			},
-			type: {
-				"const": "hipie",
-				type: "string"
-			},
-			url: {
-				type: "string"
-			}
-		},
-		required: [
-			"id",
-			"inputs",
-			"outputs",
-			"queryID",
-			"querySet",
-			"type",
-			"url"
-		],
-		type: "object"
-	},
-	IHipieSqlRef: {
-		additionalProperties: false,
-		properties: {
-			id: {
-				type: "string"
-			}
-		},
-		required: [
-			"id"
-		],
-		type: "object"
-	},
-	ILimit: {
-		additionalProperties: false,
-		properties: {
-			limit: {
-				type: "number"
-			},
-			type: {
-				"const": "limit",
-				type: "string"
-			}
-		},
-		required: [
-			"limit",
-			"type"
-		],
-		type: "object"
-	},
-	ILogicalFile: {
-		additionalProperties: false,
-		properties: {
-			fields: {
-				items: {
-					$ref: "#/definitions/IField"
-				},
-				type: "array"
-			},
-			id: {
-				type: "string"
-			},
-			logicalFile: {
-				type: "string"
-			},
-			type: {
-				"const": "logicalfile",
-				type: "string"
-			},
-			url: {
-				type: "string"
-			}
-		},
-		required: [
-			"fields",
-			"id",
-			"logicalFile",
-			"type",
-			"url"
-		],
-		type: "object"
-	},
-	IMap: {
-		additionalProperties: false,
-		properties: {
-			"default": {
-			},
-			fieldID: {
-				type: "string"
-			},
-			mappings: {
-				items: {
-					$ref: "#/definitions/IMapMapping"
-				},
-				type: "array"
-			},
-			sourceFieldID: {
-				type: "string"
-			},
-			type: {
-				"const": "map",
-				type: "string"
-			}
-		},
-		required: [
-			"fieldID",
-			"type",
-			"sourceFieldID",
-			"default",
-			"mappings"
-		],
-		type: "object"
-	},
-	IMapMapping: {
-		additionalProperties: false,
-		properties: {
-			newValue: {
-			},
-			value: {
-			}
-		},
-		required: [
-			"value",
-			"newValue"
-		],
-		type: "object"
-	},
-	IMapping: {
-		additionalProperties: false,
-		properties: {
-			condition: {
-				$ref: "#/definitions/IMappingConditionType"
-			},
-			localFieldID: {
-				type: "string"
-			},
-			nullable: {
-				type: "boolean"
-			},
-			remoteFieldID: {
-				type: "string"
-			}
-		},
-		required: [
-			"remoteFieldID",
-			"localFieldID",
-			"condition",
-			"nullable"
-		],
-		type: "object"
-	},
-	IMappingConditionType: {
-		"enum": [
-			"==",
-			"!=",
-			">",
-			">=",
-			"<",
-			"<=",
-			"range",
-			"in"
-		],
-		type: "string"
-	},
-	IMappings: {
-		additionalProperties: false,
-		properties: {
-			transformations: {
-				items: {
-					$ref: "#/definitions/ProjectTransformationType"
-				},
-				type: "array"
-			},
-			type: {
-				"const": "mappings",
-				type: "string"
-			}
-		},
-		required: [
-			"transformations",
-			"type"
-		],
-		type: "object"
-	},
-	IMulti: {
-		additionalProperties: false,
-		properties: {
-			fieldID: {
-				type: "string"
-			},
-			transformations: {
-				items: {
-					$ref: "#/definitions/MultiTransformationType"
-				},
-				type: "array"
-			},
-			type: {
-				"const": "multi",
-				type: "string"
-			}
-		},
-		required: [
-			"fieldID",
-			"type",
-			"transformations"
-		],
-		type: "object"
-	},
-	IOutput: {
-		additionalProperties: false,
-		properties: {
-			fields: {
-				items: {
-					$ref: "#/definitions/IField"
-				},
-				type: "array"
-			}
-		},
-		required: [
-			"fields"
-		],
-		type: "object"
-	},
-	IProject: {
-		additionalProperties: false,
-		properties: {
-			transformations: {
-				items: {
-					$ref: "#/definitions/ProjectTransformationType"
-				},
-				type: "array"
-			},
-			type: {
-				"const": "project",
-				type: "string"
-			}
-		},
-		required: [
-			"transformations",
-			"type"
-		],
-		type: "object"
-	},
-	IProperties: {
-		type: "object"
-	},
-	IRequestField: {
-		additionalProperties: false,
-		properties: {
-			localFieldID: {
-				type: "string"
-			},
-			remoteFieldID: {
-				type: "string"
-			},
-			source: {
-				type: "string"
-			},
-			value: {
-				type: "string"
-			}
-		},
-		required: [
-			"localFieldID",
-			"source",
-			"remoteFieldID",
-			"value"
-		],
-		type: "object"
-	},
-	IRestService: {
-		additionalProperties: false,
-		properties: {
-			action: {
-				type: "string"
-			},
-			id: {
-				type: "string"
-			},
-			inputs: {
-				items: {
-					$ref: "#/definitions/IField"
-				},
-				type: "array"
-			},
-			mode: {
-				"enum": [
-					"get",
-					"post"
-				],
-				type: "string"
-			},
-			outputs: {
-				$ref: "#/definitions/OutputDict"
-			},
-			type: {
-				"const": "rest",
-				type: "string"
-			},
-			url: {
-				type: "string"
-			}
-		},
-		required: [
-			"action",
-			"id",
-			"inputs",
-			"outputs",
-			"type",
-			"url"
-		],
-		type: "object"
-	},
-	IRoxieService: {
-		additionalProperties: false,
-		properties: {
-			id: {
-				type: "string"
-			},
-			inputs: {
-				items: {
-					$ref: "#/definitions/IField"
-				},
-				type: "array"
-			},
-			outputs: {
-				$ref: "#/definitions/OutputDict"
-			},
-			queryID: {
-				type: "string"
-			},
-			querySet: {
-				type: "string"
-			},
-			type: {
-				"const": "roxie",
-				type: "string"
-			},
-			url: {
-				type: "string"
-			}
-		},
-		required: [
-			"id",
-			"inputs",
-			"outputs",
-			"queryID",
-			"querySet",
-			"type",
-			"url"
-		],
-		type: "object"
-	},
-	IRoxieServiceRef: {
-		additionalProperties: false,
-		properties: {
-			id: {
-				type: "string"
-			},
-			output: {
-				type: "string"
-			},
-			request: {
-				items: {
-					$ref: "#/definitions/IRequestField"
-				},
-				type: "array"
-			}
-		},
-		required: [
-			"id",
-			"output",
-			"request"
-		],
-		type: "object"
-	},
-	IScale: {
-		additionalProperties: false,
-		properties: {
-			factor: {
-				type: "number"
-			},
-			fieldID: {
-				type: "string"
-			},
-			sourceFieldID: {
-				type: "string"
-			},
-			type: {
-				"const": "scale",
-				type: "string"
-			}
-		},
-		required: [
-			"fieldID",
-			"type",
-			"sourceFieldID",
-			"factor"
-		],
-		type: "object"
-	},
-	ISort: {
-		additionalProperties: false,
-		properties: {
-			conditions: {
-				items: {
-					$ref: "#/definitions/ISortCondition"
-				},
-				type: "array"
-			},
-			type: {
-				"const": "sort",
-				type: "string"
-			}
-		},
-		required: [
-			"conditions",
-			"type"
-		],
-		type: "object"
-	},
-	ISortCondition: {
-		additionalProperties: false,
-		properties: {
-			descending: {
-				type: "boolean"
-			},
-			fieldID: {
-				type: "string"
-			}
-		},
-		required: [
-			"fieldID",
-			"descending"
-		],
-		type: "object"
-	},
-	ITemplate: {
-		additionalProperties: false,
-		properties: {
-			fieldID: {
-				type: "string"
-			},
-			template: {
-				type: "string"
-			},
-			type: {
-				"const": "template",
-				type: "string"
-			}
-		},
-		required: [
-			"fieldID",
-			"type",
-			"template"
-		],
-		type: "object"
-	},
-	IView: {
-		additionalProperties: false,
-		properties: {
-			activities: {
-				items: {
-					$ref: "#/definitions/ActivityType"
-				},
-				type: "array"
-			},
-			datasource: {
-				$ref: "#/definitions/IDatasourceRef"
-			},
-			id: {
-				type: "string"
-			},
-			visualization: {
-				$ref: "#/definitions/IVisualization"
-			}
-		},
-		required: [
-			"id",
-			"datasource",
-			"activities",
-			"visualization"
-		],
-		type: "object"
-	},
-	IVisualization: {
-		additionalProperties: false,
-		properties: {
-			__class: {
-				type: "string"
-			},
-			chartType: {
-				type: "string"
-			},
-			description: {
-				type: "string"
-			},
-			id: {
-				type: "string"
-			},
-			mappings: {
-				$ref: "#/definitions/IMappings"
-			},
-			properties: {
-				$ref: "#/definitions/IWidgetProperties"
-			},
-			secondaryDataviewID: {
-				type: "string"
-			},
-			title: {
-				type: "string"
-			},
-			visibility: {
-				$ref: "#/definitions/VisibilityType"
-			}
-		},
-		required: [
-			"__class",
-			"chartType",
-			"id",
-			"mappings",
-			"properties",
-			"title",
-			"visibility"
-		],
-		type: "object"
-	},
-	IWUResult: {
-		additionalProperties: false,
-		properties: {
-			id: {
-				type: "string"
-			},
-			outputs: {
-				$ref: "#/definitions/OutputDict"
-			},
-			type: {
-				"const": "wuresult",
-				type: "string"
-			},
-			url: {
-				type: "string"
-			},
-			wuid: {
-				type: "string"
-			}
-		},
-		required: [
-			"id",
-			"outputs",
-			"type",
-			"url",
-			"wuid"
-		],
-		type: "object"
-	},
-	IWUResultRef: {
-		additionalProperties: false,
-		properties: {
-			id: {
-				type: "string"
-			},
-			output: {
-				type: "string"
-			}
-		},
-		required: [
-			"id",
-			"output"
-		],
-		type: "object"
-	},
-	IWidgetProperties: {
-		additionalProperties: {
-			anyOf: [
-				{
-					type: "string"
-				},
-				{
-					items: {
-						type: "string"
-					},
-					type: "array"
-				},
-				{
-					type: "number"
-				},
-				{
-					type: "boolean"
-				},
-				{
-					not: {
-					}
-				},
-				{
-					$ref: "#/definitions/IWidgetProperties"
-				},
-				{
-					items: {
-						$ref: "#/definitions/IWidgetProperties"
-					},
-					type: "array"
-				}
-			]
-		},
-		properties: {
-			__class: {
-				type: "string"
-			}
-		},
-		required: [
-			"__class"
-		],
-		type: "object"
-	},
-	MultiTransformationType: {
-		anyOf: [
-			{
-				$ref: "#/definitions/IEquals"
-			},
-			{
-				$ref: "#/definitions/ICalculated"
-			},
-			{
-				$ref: "#/definitions/IScale"
-			},
-			{
-				$ref: "#/definitions/ITemplate"
-			},
-			{
-				$ref: "#/definitions/IMap"
-			}
-		]
-	},
-	Number64: {
-		type: "string"
-	},
-	OutputDict: {
-		additionalProperties: {
-			$ref: "#/definitions/IOutput"
-		},
-		type: "object"
-	},
-	ProjectTransformationType: {
-		anyOf: [
-			{
-				$ref: "#/definitions/MultiTransformationType"
-			},
-			{
-				$ref: "#/definitions/IMulti"
-			}
-		]
-	},
-	Range: {
-		items: {
-			type: [
-				"number",
-				"string"
-			]
-		},
-		maxItems: 2,
-		minItems: 2,
-		type: "array"
-	},
-	Schema: {
-		additionalProperties: false,
-		properties: {
-			createdBy: {
-				additionalProperties: false,
-				properties: {
-					name: {
-						type: "string"
-					},
-					version: {
-						type: "string"
-					}
-				},
-				required: [
-					"name",
-					"version"
-				],
-				type: "object"
-			},
-			datasources: {
-				items: {
-					$ref: "#/definitions/DatasourceType"
-				},
-				type: "array"
-			},
-			dataviews: {
-				items: {
-					$ref: "#/definitions/IView"
-				},
-				type: "array"
-			},
-			defs: {
-				additionalProperties: false,
-				properties: {
-					activityTypes: {
-						additionalProperties: false,
-						properties: {
-							filter: {
-								$ref: "#/definitions/IFilter"
-							},
-							groupby: {
-								$ref: "#/definitions/IGroupBy"
-							},
-							limit: {
-								$ref: "#/definitions/ILimit"
-							},
-							mappings: {
-								$ref: "#/definitions/IMappings"
-							},
-							project: {
-								$ref: "#/definitions/IProject"
-							},
-							sort: {
-								$ref: "#/definitions/ISort"
-							}
-						},
-						required: [
-							"filter",
-							"project",
-							"groupby",
-							"sort",
-							"limit",
-							"mappings"
-						],
-						type: "object"
-					},
-					aggregateTypes: {
-						additionalProperties: false,
-						properties: {
-							aggregate: {
-								$ref: "#/definitions/IAggregate"
-							},
-							count: {
-								$ref: "#/definitions/ICount"
-							}
-						},
-						required: [
-							"aggregate",
-							"count"
-						],
-						type: "object"
-					},
-					datasourceRefTypes: {
-						additionalProperties: false,
-						properties: {
-							roxieServiceRef: {
-								$ref: "#/definitions/IRoxieServiceRef"
-							},
-							wuResultRef: {
-								$ref: "#/definitions/IWUResultRef"
-							}
-						},
-						required: [
-							"wuResultRef",
-							"roxieServiceRef"
-						],
-						type: "object"
-					},
-					datasourceTypes: {
-						additionalProperties: false,
-						properties: {
-							databomb: {
-								$ref: "#/definitions/IDatabomb"
-							},
-							datasource: {
-								$ref: "#/definitions/IDatasource"
-							},
-							form: {
-								$ref: "#/definitions/IForm"
-							},
-							hipieService: {
-								$ref: "#/definitions/IHipieService"
-							},
-							logicalFile: {
-								$ref: "#/definitions/ILogicalFile"
-							},
-							roxieService: {
-								$ref: "#/definitions/IRoxieService"
-							},
-							wuresult: {
-								$ref: "#/definitions/IWUResult"
-							}
-						},
-						required: [
-							"datasource",
-							"logicalFile",
-							"form",
-							"databomb",
-							"wuresult",
-							"hipieService",
-							"roxieService"
-						],
-						type: "object"
-					},
-					fieldTypes: {
-						additionalProperties: false,
-						properties: {
-							dataset: {
-								$ref: "#/definitions/Dataset"
-							},
-							field: {
-								$ref: "#/definitions/IField"
-							},
-							fieldBoolean: {
-								$ref: "#/definitions/IFieldBoolean"
-							},
-							fieldDataset: {
-								$ref: "#/definitions/IFieldDataset"
-							},
-							fieldNumber: {
-								$ref: "#/definitions/IFieldNumber"
-							},
-							fieldNumber64: {
-								$ref: "#/definitions/IFieldNumber64"
-							},
-							fieldObject: {
-								$ref: "#/definitions/IFieldObject"
-							},
-							fieldRange: {
-								$ref: "#/definitions/IFieldRange"
-							},
-							fieldSet: {
-								$ref: "#/definitions/IFieldSet"
-							},
-							fieldString: {
-								$ref: "#/definitions/IFieldString"
-							},
-							fieldType: {
-								$ref: "#/definitions/IFieldType"
-							},
-							number64: {
-								$ref: "#/definitions/Number64"
-							},
-							range: {
-								$ref: "#/definitions/Range"
-							}
-						},
-						required: [
-							"number64",
-							"range",
-							"dataset",
-							"fieldType",
-							"fieldBoolean",
-							"fieldNumber",
-							"fieldNumber64",
-							"fieldString",
-							"fieldRange",
-							"fieldDataset",
-							"fieldSet",
-							"fieldObject",
-							"field"
-						],
-						type: "object"
-					},
-					transformationTypes: {
-						additionalProperties: false,
-						properties: {
-							calculated: {
-								$ref: "#/definitions/ICalculated"
-							},
-							equals: {
-								$ref: "#/definitions/IEquals"
-							},
-							map: {
-								$ref: "#/definitions/IMap"
-							},
-							multi: {
-								$ref: "#/definitions/IMulti"
-							},
-							scale: {
-								$ref: "#/definitions/IScale"
-							},
-							template: {
-								$ref: "#/definitions/ITemplate"
-							}
-						},
-						required: [
-							"equals",
-							"calculated",
-							"scale",
-							"template",
-							"map",
-							"multi"
-						],
-						type: "object"
-					}
-				},
-				required: [
-					"fieldTypes",
-					"datasourceTypes",
-					"datasourceRefTypes",
-					"activityTypes",
-					"aggregateTypes",
-					"transformationTypes"
-				],
-				type: "object"
-			},
-			hipieProperties: {
-				$ref: "#/definitions/IProperties"
-			},
-			properties: {
-				$ref: "#/definitions/IProperties"
-			},
-			version: {
-				"const": "2.2.1",
-				type: "string"
-			}
-		},
-		required: [
-			"version",
-			"createdBy",
-			"datasources",
-			"dataviews"
-		],
-		type: "object"
-	},
-	VisibilityType: {
-		"enum": [
-			"normal",
-			"flyout"
-		],
-		type: "string"
-	}
-};
-var v2 = {
-	$ref: $ref,
-	$schema: $schema,
-	definitions: definitions
-};
-
-var ddl2Schema = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  $ref: $ref,
-  $schema: $schema,
-  default: v2,
-  definitions: definitions
-});
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-var __assign = function() {
-  __assign = Object.assign || function __assign(t) {
-      for (var s, i = 1, n = arguments.length; i < n; i++) {
-          s = arguments[i];
-          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-      }
-      return t;
-  };
-  return __assign.apply(this, arguments);
-};
-
-function __spreadArray(to, from, pack) {
-  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-      if (ar || !(i in from)) {
-          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-          ar[i] = from[i];
-      }
-  }
-  return to.concat(ar || Array.prototype.slice.call(from));
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-  var e = new Error(message);
-  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-var PKG_NAME = "@hpcc-js/ddl-shim";
-var PKG_VERSION = "2.22.0";
-
-function isWorkunitDatasource(ref) {
-    return ref.WUID !== undefined;
-}
-function isDatabombDatasource(ref) {
-    return ref.databomb === true;
-}
-function isHipieDatasource(ref) {
-    return ref.URL !== undefined;
-}
-function isPieVisualization(viz) {
-    return viz.type === "PIE" || viz.type === "BAR";
-}
-function isLineVisualization(viz) {
-    return viz.type === "LINE";
-}
-function isChoroVisualization(viz) {
-    return viz.type === "CHORO";
-}
-function isTableVisualization(viz) {
-    return viz.type === "TABLE";
-}
-function isSliderVisualization(viz) {
-    return viz.type === "SLIDER";
-}
-function isGraphVisualization(viz) {
-    return viz.type === "GRAPH";
-}
-function isFormVisualization(viz) {
-    return viz.type === "FORM";
-}
-
-function isRoxieServiceRef(ref) {
-    return ref.request !== undefined;
-}
-
-var classMappings = {
-    c3chart_Bar: "chart_Bar",
-    c3chart_Column: "chart_Column",
-    c3chart_Pie: "chart_Pie",
-    c3chart_Area: "chart_Area",
-    c3chart_Line: "chart_Line",
-    amchart_Bar: "chart_Bar",
-    amchart_Column: "chart_Column",
-    amchart_Pie: "chart_Pie",
-    amchart_Area: "chart_Area",
-    amchart_Line: "chart_Line",
-    google_Bar: "chart_Bar",
-    google_Column: "chart_Column",
-    google_Pie: "chart_Pie",
-    google_Area: "chart_Area",
-    google_Line: "chart_Line",
-    other_Table: "dgrid_Table"
-};
-var propertyMappings = {
-    xAxisLabelRotation: [
-        { name: "xAxisOverlapMode", transform: function (n) { return "rotate"; } },
-        { name: "xAxisLabelRotation", transform: function (n) { return n; } }
-    ],
-    tooltipLabelColor: {
-        name: "tooltipLabelColor"
-    },
-    tooltipSeriesColor: {
-        name: "tooltipSeriesColor"
-    },
-    tooltipValueColor: {
-        name: "tooltipValueColor"
-    },
-    tooltipValueFormat: {
-        name: "tooltipValueFormat"
-    },
-    timePattern: {
-        name: "xAxisTypeTimePattern"
-    },
-    smoothLines: {
-        name: "interpolate",
-        transform: function (n) {
-            if (n === false)
-                return "linear";
-            return "catmullRom";
-        }
-    },
-    holePercent: {
-        name: "innerRadius"
-    },
-    flip: {
-        name: "orientation",
-        transform: function (n) { return n ? "vertical" : "horizontal"; }
-    },
-    bottomText: {
-        name: "xAxisTitle"
-    },
-    xAxisTypeTimePattern: {
-        name: "xAxisTypeTimePattern"
-    },
-    yAxisTypeTimePattern: {
-        name: "yAxisTypeTimePattern"
-    },
-    valueFormat: {
-        name: "tooltipValueFormat"
-    },
-    stacked: {
-        name: "yAxisStacked"
-    },
-    showYGrid: {
-        name: "yAxisGuideLines"
-    },
-    showXGrid: {
-        name: "xAxisGuideLines"
-    },
-    showValueLabel: {
-        name: "showValue"
-    },
-    low: {
-        name: "yAxisDomainLow"
-    },
-    high: {
-        name: "yAxisDomainHigh"
-    },
-    fillOpacity: {
-        name: "interpolateFillOpacity"
-    },
-    areaFillOpacity: {
-        name: "interpolateFillOpacity"
-    },
-    showToolbar: {
-        name: "titleVisible"
-    },
-    showCSV: {
-        name: "downloadButtonVisible"
-    }
-};
-function findKeyVal(object, key, val) {
-    var value;
-    for (var k in object) {
-        if (k === key && object[k] === val) {
-            value = object;
-            break;
-        }
-        if (object[k] && typeof object[k] === "object") {
-            value = findKeyVal(object[k], key, val);
-            if (value !== undefined) {
-                break;
-            }
-        }
-    }
-    return value;
-}
-function apply_to_dataviews(ddl2, dermObj) {
-    ddl2.dataviews.forEach(apply_to_dataview);
-    function apply_to_dataview(dv) {
-        var widgetId = dv.id;
-        var dermPanelObj = findKeyVal(dermObj, "__id", widgetId);
-        if (dermPanelObj) {
-            var dermPanelProps = dermPanelObj.__properties;
-            var dermWidgetObj = dermPanelObj.__properties.chart ? dermPanelObj.__properties.chart : dermPanelObj.__properties.widget;
-            var dermWidgetProps = dermWidgetObj.__properties;
-            apply_class_mapping(dermWidgetObj);
-            apply_panel_property_mapping(dermPanelProps, dermWidgetProps);
-            apply_widget_property_mapping(dermPanelProps, dermWidgetProps);
-            if (dv.visualization.properties.chartType) {
-                dv.visualization.properties.charttype = dv.visualization.properties.chartType;
-            }
-        }
-        else {
-            console.warn(widgetId + " not found in dermObj");
-        }
-        function apply_class_mapping(dermWidgetObj) {
-            dv.visualization.__class = swap_with_supported_class(dermWidgetObj.__class);
-            dv.visualization.properties.__class = "marshaller_VizChartPanel";
-            if (!dv.visualization.properties.widget)
-                dv.visualization.properties.widget = {};
-            dv.visualization.properties.widget.__class = dv.visualization.__class;
-            function swap_with_supported_class(_class) {
-                return classMappings[_class] ? classMappings[_class] : _class;
-            }
-        }
-        function apply_panel_property_mapping(dermPanelProps, dermWidgetProps) {
-            dv.visualization.title = dermPanelProps.title || "";
-            dv.visualization.description = "";
-            dv.visualization.visibility = dv.visualization.visibility === "flyout" ? "flyout" : "normal";
-            dv.visualization.chartType = dv.visualization.__class.split("_")[1];
-            for (var propName in dermPanelProps) {
-                if (typeof propertyMappings[propName] !== "undefined") {
-                    var newPropName = propertyMappings[propName].name;
-                    if (typeof propertyMappings[propName].transform === "function") {
-                        dv.visualization.properties[newPropName] = propertyMappings[propName].transform(dermPanelProps[propName]);
-                    }
-                    else {
-                        dv.visualization.properties[newPropName] = dermPanelProps[propName];
-                    }
-                }
-            }
-            if (dermWidgetProps && dermWidgetProps.showLegend && dv.visualization.properties) {
-                dv.visualization.properties.legendVisible = true;
-            }
-        }
-        function apply_widget_property_mapping(dermPanelProps, dermWidgetProps) {
-            dv.visualization.title = dv.visualization.title || dermWidgetProps.title || "";
-            dv.visualization.description = ""; // TODO - should this map to anything?
-            dv.visualization.visibility = dv.visualization.visibility === "flyout" ? "flyout" : "normal";
-            dv.visualization.chartType = dv.visualization.__class.split("_")[1];
-            var _loop_1 = function (propName) {
-                if (typeof propertyMappings[propName] !== "undefined") {
-                    if (propertyMappings[propName] instanceof Array) {
-                        propertyMappings[propName].forEach(function (p) {
-                            var newPropName = p.name;
-                            dv.visualization.properties.widget[newPropName] = p.transform(dermWidgetProps[propName]);
-                            if (typeof propertyMappings[propName].transform === "function") {
-                                dv.visualization.properties.widget[newPropName] = propertyMappings[propName].transform(dermWidgetProps[propName]);
-                            }
-                            else {
-                                dv.visualization.properties.widget[newPropName] = dermWidgetProps[propName];
-                            }
-                        });
-                    }
-                    else {
-                        var newPropName = propertyMappings[propName].name;
-                        dv.visualization.properties.widget[newPropName] = propertyMappings[propName].transform(dermWidgetProps[propName]);
-                    }
-                }
-            };
-            for (var propName in dermWidgetProps) {
-                _loop_1(propName);
-            }
-        }
-    }
-}
-function apply_to_properties_layout(ddl2, dermObj) {
-    var retVal = {
-        layout: []
-    };
-    if (!dermObj || !dermObj.__properties)
-        return;
-    dermObj.__properties.content.forEach(function (cell) {
-        var cellPosition = {
-            // TODO - if "id" could be avoided then layouts could apply to any dashboard with the same number of widgets
-            id: cell.__properties.widget.__id,
-            position: [
-                cell.__properties.gridCol,
-                cell.__properties.gridRow,
-                cell.__properties.gridColSpan,
-                cell.__properties.gridRowSpan
-            ]
-        };
-        retVal.layout.push(cellPosition);
-    });
-    return retVal;
-}
-function upgrade$1(ddl2, dermObj) {
-    apply_to_dataviews(ddl2, dermObj);
-    return apply_to_properties_layout(ddl2, dermObj);
-}
-
-function faCharFix(faChar) {
-    return faChar;
-}
-var DDLUpgrade = /** @class */ (function () {
-    function DDLUpgrade(ddl, baseUrl, wuid, toLowerCase) {
-        if (baseUrl === void 0) { baseUrl = "http://localhost:8010"; }
-        if (wuid === void 0) { wuid = "WUID"; }
-        if (toLowerCase === void 0) { toLowerCase = true; }
-        this._datasources = {};
-        this._datasourceUpdates = {};
-        this._visualizations = {};
-        this._ddl2Datasources = {};
-        this._ddl2DatasourceFields = {};
-        this._ddl2Dataviews = {};
-        this._ddl2DataviewActivities = {};
-        this._ddl = ddl;
-        this._baseUrl = baseUrl;
-        this._wuid = wuid;
-        this._toLowerCase = toLowerCase;
-        this.indexDDL();
-        this.readDDL();
-    }
-    DDLUpgrade.prototype.toLowerCase = function (s) {
-        return this._toLowerCase ? s.toLowerCase() : s;
-    };
-    DDLUpgrade.prototype.isVizDatasourceRoxie = function (viz) {
-        if (viz.source) {
-            var ds = this._datasources[viz.source.id];
-            if (isHipieDatasource(ds)) {
-                return true;
-            }
-        }
-        return false;
-    };
-    DDLUpgrade.prototype.getDatasourceOutputs = function (dsID, vizID) {
-        var retVal = [];
-        var datasource = this._datasources[dsID];
-        for (var _i = 0, _a = datasource.outputs; _i < _a.length; _i++) {
-            var output = _a[_i];
-            if (output.notify) {
-                for (var _b = 0, _c = output.notify; _b < _c.length; _b++) {
-                    var notify = _c[_b];
-                    if (notify === vizID) {
-                        retVal.push({
-                            datasource: datasource,
-                            output: output
-                        });
-                    }
-                }
-            }
-        }
-        return retVal;
-    };
-    DDLUpgrade.prototype.getDatasourceFilters = function (dsID, vizID) {
-        var retVal = {};
-        for (var _i = 0, _a = this.getDatasourceOutputs(dsID, vizID); _i < _a.length; _i++) {
-            var dsOut = _a[_i];
-            if (dsOut.output.filter) {
-                for (var _b = 0, _c = dsOut.output.filter; _b < _c.length; _b++) {
-                    var filter = _c[_b];
-                    retVal[filter.fieldid] = {
-                        datasource: dsOut.datasource,
-                        output: dsOut.output,
-                        filter: filter
-                    };
-                }
-            }
-        }
-        return retVal;
-    };
-    DDLUpgrade.prototype.indexDDL = function () {
-        for (var _i = 0, _a = this._ddl.dashboards; _i < _a.length; _i++) {
-            var dash = _a[_i];
-            for (var _b = 0, _c = dash.visualizations; _b < _c.length; _b++) {
-                var viz = _c[_b];
-                this._visualizations[viz.id] = viz;
-            }
-        }
-        for (var _d = 0, _e = this._ddl.datasources; _d < _e.length; _d++) {
-            var ds = _e[_d];
-            this._datasources[ds.id] = ds;
-            for (var _f = 0, _g = ds.outputs; _f < _g.length; _f++) {
-                var output = _g[_f];
-                if (output.notify) {
-                    for (var _h = 0, _j = output.notify; _h < _j.length; _h++) {
-                        var notify = _j[_h];
-                        this._datasourceUpdates[notify] = {
-                            id: ds.id,
-                            output: output.from || output.id
-                        };
-                    }
-                }
-            }
-        }
-    };
-    DDLUpgrade.prototype.readDDL = function () {
-        for (var _i = 0, _a = this._ddl.datasources; _i < _a.length; _i++) {
-            var ds = _a[_i];
-            if (isWorkunitDatasource(ds)) {
-                var ddl2DS = {
-                    type: "wuresult",
-                    id: ds.id,
-                    url: this._baseUrl,
-                    wuid: this._wuid,
-                    outputs: {}
-                };
-                for (var _b = 0, _c = ds.outputs; _b < _c.length; _b++) {
-                    var output = _c[_b];
-                    this.output2output(output, ddl2DS.outputs);
-                }
-                this._ddl2Datasources[ds.id] = ddl2DS;
-            }
-            else if (isDatabombDatasource(ds)) ;
-            else {
-                var urlParts = ds.URL.split("/WsEcl/submit/query/");
-                var hostParts = urlParts[0];
-                var roxieParts = urlParts[1].split("/");
-                var ddl2DS = {
-                    type: "hipie",
-                    id: ds.id,
-                    url: hostParts,
-                    querySet: roxieParts[0],
-                    queryID: roxieParts[1],
-                    inputs: [],
-                    outputs: {}
-                };
-                for (var _d = 0, _e = ds.outputs; _d < _e.length; _d++) {
-                    var output = _e[_d];
-                    this.output2output(output, ddl2DS.outputs);
-                }
-                this._ddl2Datasources[ds.id] = ddl2DS;
-            }
-        }
-        for (var _f = 0, _g = this._ddl.dashboards; _f < _g.length; _f++) {
-            var dash = _g[_f];
-            for (var _h = 0, _j = dash.visualizations; _h < _j.length; _h++) {
-                var viz = _j[_h];
-                if (viz.type === "FORM") {
-                    this._ddl2Datasources[viz.id] = {
-                        type: "form",
-                        id: viz.id,
-                        fields: this.formFields2field(viz.fields)
-                    };
-                    this._datasourceUpdates[viz.id] = { id: viz.id };
-                }
-                else if (viz.type === "SLIDER") {
-                    this._ddl2Datasources[viz.id] = {
-                        type: "form",
-                        id: viz.id,
-                        fields: this.formFields2field(viz.fields, true)
-                    };
-                    this._datasourceUpdates[viz.id] = { id: viz.id };
-                }
-                this._ddl2Dataviews[viz.id] = this.anyViz2view(viz);
-            }
-        }
-        this.readGroupBy();
-        this.readFilters();
-        this.readSort();
-        this.readMappings();
-    };
-    DDLUpgrade.prototype.readGroupBy = function () {
-        for (var _i = 0, _a = this._ddl.dashboards; _i < _a.length; _i++) {
-            var dash = _a[_i];
-            for (var _b = 0, _c = dash.visualizations; _b < _c.length; _b++) {
-                var viz = _c[_b];
-                if (viz.fields) {
-                    var projectTransformations = [];
-                    var groupByColumns = [];
-                    var aggrFields = [];
-                    for (var _d = 0, _e = viz.fields; _d < _e.length; _d++) {
-                        var field = _e[_d];
-                        if (field.properties && field.properties.function) {
-                            switch (field.properties.function) {
-                                case "SUM":
-                                case "MIN":
-                                case "MAX":
-                                    aggrFields.push({
-                                        type: this.func2aggr(field.properties.function),
-                                        inFieldID: this.toLowerCase(field.properties.params.param1),
-                                        fieldID: this.toLowerCase(field.id)
-                                    });
-                                    break;
-                                case "AVE":
-                                    aggrFields.push({
-                                        type: this.func2aggr(field.properties.function),
-                                        inFieldID: this.toLowerCase(field.properties.params.param1),
-                                        baseCountFieldID: field.properties.params.param2 ? this.toLowerCase(field.properties.params.param2) : undefined,
-                                        fieldID: this.toLowerCase(field.id)
-                                    });
-                                    break;
-                                case "SCALE":
-                                    if (typeof field.properties.params.param1 === "object") {
-                                        var props = field.properties.params.param1;
-                                        switch (props.function) {
-                                            case "SUM":
-                                            case "MIN":
-                                            case "MAX":
-                                                aggrFields.push({
-                                                    type: this.func2aggr(props.function),
-                                                    inFieldID: this.toLowerCase(props.params.param1),
-                                                    fieldID: this.toLowerCase(field.id)
-                                                });
-                                                break;
-                                        }
-                                    }
-                                    projectTransformations.push({
-                                        type: "scale",
-                                        sourceFieldID: this.toLowerCase(field.id),
-                                        fieldID: this.toLowerCase(field.id),
-                                        factor: +field.properties.params.param2
-                                    });
-                                    break;
-                                default:
-                                    groupByColumns.push(this.toLowerCase(field.id));
-                                    throw new Error("Unhandled field function: ".concat(field.properties.function));
-                            }
-                        }
-                        else {
-                            groupByColumns.push(this.toLowerCase(field.id));
-                        }
-                    }
-                    if (projectTransformations.length) {
-                        this._ddl2DataviewActivities[viz.id].project.transformations = projectTransformations;
-                    }
-                    if (aggrFields.length) {
-                        this._ddl2DataviewActivities[viz.id].groupBy.groupByIDs = __spreadArray([], groupByColumns, true);
-                        this._ddl2DataviewActivities[viz.id].groupBy.aggregates = aggrFields;
-                    }
-                }
-            }
-        }
-    };
-    DDLUpgrade.prototype.func2aggr = function (func) {
-        switch (func) {
-            case "SUM":
-                return "sum";
-            case "AVE":
-                return "mean";
-            case "MIN":
-                return "min";
-            case "MAX":
-                return "max";
-        }
-        throw new Error("Unknown DDL1 Function Type:  ".concat(func));
-    };
-    DDLUpgrade.prototype.readMappings = function () {
-        for (var _i = 0, _a = this._ddl.dashboards; _i < _a.length; _i++) {
-            var dash = _a[_i];
-            for (var _b = 0, _c = dash.visualizations; _b < _c.length; _b++) {
-                var viz = _c[_b];
-                if (isFormVisualization(viz)) ;
-                else if (isPieVisualization(viz)) {
-                    this.readPieMappings(viz);
-                }
-                else if (isChoroVisualization(viz)) {
-                    this.readChoroMappings(viz);
-                }
-                else if (isLineVisualization(viz)) {
-                    this.readLineMappings(viz);
-                }
-                else if (isTableVisualization(viz)) {
-                    this.readTableMappings(viz);
-                }
-                else if (isGraphVisualization(viz)) {
-                    this.readGraphMappings(viz);
-                }
-                else if (isSliderVisualization(viz)) {
-                    this.readSliderMappings(viz);
-                }
-                else {
-                    throw new Error("Unkown DDL1 mapping type:  ".concat(viz.type));
-                }
-            }
-        }
-    };
-    DDLUpgrade.prototype.readPieMappings = function (viz) {
-        var mappings = this._ddl2DataviewActivities[viz.id].mappings;
-        mappings.transformations.push({
-            fieldID: "label",
-            type: "=",
-            sourceFieldID: this.toLowerCase(viz.source.mappings.label)
-        });
-        mappings.transformations.push({
-            fieldID: "weight",
-            type: "=",
-            sourceFieldID: this.toLowerCase(viz.source.mappings.weight[0])
-        });
-    };
-    DDLUpgrade.prototype.readChoroMappings = function (viz) {
-        var mappings = this._ddl2DataviewActivities[viz.id].mappings;
-        mappings.transformations.push({
-            fieldID: "label",
-            type: "=",
-            sourceFieldID: this.toLowerCase(this.anyChoroMapping2label(viz.source.mappings))
-        });
-        mappings.transformations.push({
-            fieldID: "weight",
-            type: "=",
-            sourceFieldID: this.toLowerCase(viz.source.mappings.weight[0])
-        });
-    };
-    DDLUpgrade.prototype.anyChoroMapping2label = function (mapping) {
-        return mapping.state || mapping.county || mapping.geohash;
-    };
-    DDLUpgrade.prototype.readLineMappings = function (viz) {
-        var mappings = this._ddl2DataviewActivities[viz.id].mappings;
-        mappings.transformations.push({
-            fieldID: viz.source.mappings.x[0],
-            type: "=",
-            sourceFieldID: this.toLowerCase(viz.source.mappings.x[0])
-        });
-        for (var i = 0; i < viz.source.mappings.y.length; ++i) {
-            mappings.transformations.push({
-                fieldID: viz.source.mappings.y[i],
-                type: "=",
-                sourceFieldID: this.toLowerCase(viz.source.mappings.y[i])
-            });
-        }
-    };
-    DDLUpgrade.prototype.readTableMappings = function (viz) {
-        var mappings = this._ddl2DataviewActivities[viz.id].mappings;
-        for (var i = 0; i < viz.label.length; ++i) {
-            mappings.transformations.push({
-                fieldID: viz.label[i],
-                type: "=",
-                sourceFieldID: this.toLowerCase(viz.source.mappings.value[i])
-            });
-        }
-    };
-    DDLUpgrade.prototype.readGraphEnums = function (valueMappings, annotation) {
-        if (annotation === void 0) { annotation = false; }
-        var retVal = [];
-        if (valueMappings) {
-            for (var value in valueMappings) {
-                var newValue = {};
-                for (var key in valueMappings[value]) {
-                    if (key === "faChar") {
-                        newValue[key] = faCharFix(valueMappings[value][key]);
-                    }
-                    else if (annotation && key.indexOf("icon_") === 0) {
-                        console.warn("Deprecated flag property:  " + key);
-                        newValue[key.split("icon_")[1]] = valueMappings[value][key];
-                    }
-                    else {
-                        newValue[key] = valueMappings[value][key];
-                    }
-                }
-                //  remove v1.x "0" annotations as they equated to "nothing"  ---
-                if (!annotation || value !== "0") {
-                    retVal.push({
-                        value: value,
-                        newValue: newValue
-                    });
-                }
-            }
-        }
-        return retVal;
-    };
-    DDLUpgrade.prototype.readGraphMappings = function (viz) {
-        var mappings = this._ddl2DataviewActivities[viz.id].mappings;
-        mappings.transformations.push({
-            fieldID: "uid",
-            type: "=",
-            sourceFieldID: this.toLowerCase(viz.source.mappings.uid)
-        });
-        mappings.transformations.push({
-            fieldID: "label",
-            type: "=",
-            sourceFieldID: this.toLowerCase(viz.source.mappings.label)
-        });
-        if (viz.icon.fieldid) {
-            mappings.transformations.push({
-                fieldID: "icon",
-                type: "map",
-                sourceFieldID: this.toLowerCase(viz.icon.fieldid),
-                default: { fachar: faCharFix(viz.icon.faChar) },
-                mappings: this.readGraphEnums(viz.icon.valuemappings)
-            });
-        }
-        var idx = 0;
-        if (viz.flag) {
-            for (var _i = 0, _a = viz.flag; _i < _a.length; _i++) {
-                var flag = _a[_i];
-                if (flag.fieldid) {
-                    mappings.transformations.push({
-                        fieldID: "annotation_".concat(idx++),
-                        type: "map",
-                        sourceFieldID: this.toLowerCase(flag.fieldid),
-                        default: {},
-                        mappings: this.readGraphEnums(flag.valuemappings, true)
-                    });
-                }
-            }
-        }
-        mappings.transformations.push({
-            fieldID: "links",
-            type: "=",
-            sourceFieldID: this.toLowerCase(viz.source.link.childfile),
-            transformations: [{
-                    fieldID: "uid",
-                    type: "=",
-                    sourceFieldID: this.toLowerCase(viz.source.link.mappings.uid)
-                }]
-        });
-    };
-    DDLUpgrade.prototype.readSliderMappings = function (viz) {
-        var mappings = this._ddl2DataviewActivities[viz.id].mappings;
-        mappings.transformations.push({
-            fieldID: "label",
-            type: "=",
-            sourceFieldID: this.toLowerCase(viz.source.mappings.label)
-        });
-    };
-    DDLUpgrade.prototype.readFilters = function () {
-        for (var _i = 0, _a = this._ddl.dashboards; _i < _a.length; _i++) {
-            var dash = _a[_i];
-            for (var _b = 0, _c = dash.visualizations; _b < _c.length; _b++) {
-                var viz = _c[_b];
-                if (viz.events) {
-                    for (var eventID in viz.events) {
-                        var event_1 = viz.events[eventID];
-                        for (var _d = 0, _e = event_1.updates; _d < _e.length; _d++) {
-                            var update = _e[_d];
-                            var otherViz = this._ddl2Dataviews[update.visualization];
-                            var dsFilters = this.getDatasourceFilters(update.datasource, otherViz.id);
-                            if (update.mappings) {
-                                if (isRoxieServiceRef(otherViz.datasource)) {
-                                    for (var key in update.mappings) {
-                                        otherViz.datasource.request.push({
-                                            source: viz.id,
-                                            remoteFieldID: this.toLowerCase(key),
-                                            localFieldID: this.toLowerCase(update.mappings[key])
-                                        });
-                                    }
-                                }
-                                else {
-                                    var condition = {
-                                        viewID: viz.id,
-                                        mappings: []
-                                    };
-                                    for (var key in update.mappings) {
-                                        var mapping = update.mappings[key];
-                                        var dsFilter = (mapping && dsFilters[mapping]) ? dsFilters[mapping].filter : undefined;
-                                        if (!dsFilter) {
-                                            console.warn("Select Mapping \"".concat(mapping, "\" in viz \"").concat(viz.id, "\" not found in filters for \"").concat(otherViz.id, "\""));
-                                        }
-                                        else {
-                                            condition.mappings.push({
-                                                remoteFieldID: this.toLowerCase(key),
-                                                localFieldID: this.toLowerCase(update.mappings[key]),
-                                                condition: this.rule2condition(dsFilter.rule),
-                                                nullable: dsFilter.nullable
-                                            });
-                                        }
-                                    }
-                                    this._ddl2DataviewActivities[otherViz.id].filters.conditions.push(condition);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    };
-    DDLUpgrade.prototype.rule2condition = function (_) {
-        switch (_) {
-            case "set":
-                return "in";
-            case "notequals":
-                return "!=";
-        }
-        return _;
-    };
-    DDLUpgrade.prototype.readSort = function () {
-        var _this = this;
-        for (var _i = 0, _a = this._ddl.dashboards; _i < _a.length; _i++) {
-            var dash = _a[_i];
-            for (var _b = 0, _c = dash.visualizations; _b < _c.length; _b++) {
-                var viz = _c[_b];
-                if (viz.source) {
-                    if (viz.source.sort) {
-                        var vizSort = this._ddl2DataviewActivities[viz.id].sort;
-                        vizSort.conditions = viz.source.sort.map(function (s) {
-                            if (s.indexOf("-") === 0) {
-                                return {
-                                    fieldID: _this.toLowerCase(s.substr(1)),
-                                    descending: true
-                                };
-                            }
-                            return {
-                                fieldID: _this.toLowerCase(s),
-                                descending: false
-                            };
-                        });
-                    }
-                    if (viz.source.first) {
-                        var vizLimit = this._ddl2DataviewActivities[viz.id].limit;
-                        vizLimit.limit = +viz.source.first;
-                    }
-                }
-            }
-        }
-    };
-    DDLUpgrade.prototype.anyViz2view = function (viz) {
-        var project = {
-            type: "project",
-            transformations: []
-        };
-        var filters = {
-            type: "filter",
-            conditions: []
-        };
-        var groupBy = {
-            type: "groupby",
-            groupByIDs: [],
-            aggregates: []
-        };
-        var sort = {
-            type: "sort",
-            conditions: []
-        };
-        var limit = {
-            type: "limit",
-            limit: 0
-        };
-        var mappings = {
-            type: "mappings",
-            transformations: []
-        };
-        this._ddl2DataviewActivities[viz.id] = {
-            project: project,
-            filters: filters,
-            sort: sort,
-            groupBy: groupBy,
-            limit: limit,
-            mappings: mappings
-        };
-        var datasourceRef = this.isVizDatasourceRoxie(viz) ? {
-            id: this._datasourceUpdates[viz.id].id,
-            request: [],
-            output: this._datasourceUpdates[viz.id].output
-        } : {
-            id: this._datasourceUpdates[viz.id].id,
-            output: this._datasourceUpdates[viz.id].output
-        };
-        return {
-            id: viz.id,
-            datasource: datasourceRef,
-            activities: [
-                project,
-                filters,
-                sort,
-                groupBy,
-                limit
-            ],
-            visualization: __assign(__assign({ id: viz.id, title: viz.title || "", description: "", visibility: viz.properties && viz.properties.flyout === true ? "flyout" : "normal" }, this.type2chartType(viz.type)), { mappings: mappings, properties: (viz.properties || {}) })
-        };
-    };
-    DDLUpgrade.prototype.type2chartType = function (chartType) {
-        switch (chartType) {
-            case "LINE":
-                return { chartType: "Line", __class: "chart_Line" };
-            case "BUBBLE":
-                return { chartType: "Bubble", __class: "chart_Bubble" };
-            case "PIE":
-                return { chartType: "Pie", __class: "chart_Pie" };
-            case "BAR":
-                return { chartType: "Column", __class: "chart_Column" };
-            case "FORM":
-                return { chartType: "FieldForm", __class: "form_FieldForm" };
-            case "WORD_CLOUD":
-                return { chartType: "WordCloud", __class: "chart_WordCloud" };
-            case "CHORO":
-                return { chartType: "ChoroplethStates", __class: "map_ChoroplethStates" };
-            case "SUMMARY":
-                return { chartType: "Summary", __class: "chart_Summary" };
-            case "SLIDER":
-                return { chartType: "FieldForm", __class: "form_FieldForm" };
-            case "HEAT_MAP":
-                return { chartType: "HeatMap", __class: "other_HeatMap" };
-            case "2DCHART":
-                return { chartType: "Column", __class: "chart_Column" };
-            case "GRAPH":
-                return { chartType: "AdjacencyGraph", __class: "graph_AdjacencyGraph" };
-            case "TABLE":
-            default:
-                return { chartType: "Table", __class: "dgrid_Table" };
-        }
-    };
-    DDLUpgrade.prototype.formFields2field = function (fields, slider) {
-        var _this = this;
-        if (slider === void 0) { slider = false; }
-        if (!fields)
-            return [];
-        return fields.map(function (field) {
-            switch (field.properties.type) {
-                case "range":
-                    return {
-                        type: "range",
-                        id: field.id,
-                        default: (field.properties.default ? field.properties.default : undefined)
-                    };
-                case "dataset":
-                    return {
-                        type: "dataset",
-                        id: field.id,
-                        default: [],
-                        children: []
-                    };
-                default:
-                    return {
-                        type: _this.formFieldType2fieldType(field.properties.datatype, slider),
-                        id: field.id,
-                        default: field.properties.default ? field.properties.default[0] : undefined
-                    };
-            }
-        });
-    };
-    DDLUpgrade.prototype.formFieldType2fieldType = function (fieldType, slider) {
-        switch (fieldType) {
-            case "bool":
-            case "boolean":
-                return "boolean";
-            case "integer":
-            case "unsigned":
-            case "float":
-            case "double":
-            case "real":
-                return "number";
-            case "string":
-                return "string";
-            default:
-                return slider ? "number" : "string";
-        }
-    };
-    DDLUpgrade.prototype.output2output = function (output, target) {
-        target[output.from || output.id] = {
-            fields: this.filters2fields(output.filter)
-        };
-    };
-    DDLUpgrade.prototype.filters2fields = function (filters) {
-        if (!filters)
-            return [];
-        return filters.filter(function (filter) {
-            var idParts = filter.fieldid.split("-");
-            return idParts.length === 1 || idParts[1] === "range";
-        }).map(function (filter) {
-            var idParts = filter.fieldid.split("-");
-            var retVal = {
-                type: "string",
-                id: idParts[0]
-            };
-            return retVal;
-        });
-    };
-    DDLUpgrade.prototype.getVizField = function (vizID, fieldID) {
-        return {
-            type: "string",
-            id: "",
-            default: ""
-        };
-    };
-    DDLUpgrade.prototype.writeDatasources = function () {
-        var retVal = [];
-        for (var id in this._ddl2Datasources) {
-            retVal.push(this._ddl2Datasources[id]);
-        }
-        return retVal;
-    };
-    DDLUpgrade.prototype.writeDataviews = function () {
-        var retVal = [];
-        for (var id in this._ddl2Dataviews) {
-            retVal.push(this._ddl2Dataviews[id]);
-        }
-        return retVal;
-    };
-    DDLUpgrade.prototype.writeProperties = function () {
-        return {
-        //  TODO
-        };
-    };
-    DDLUpgrade.prototype.write = function () {
-        return {
-            version: "2.2.1",
-            createdBy: {
-                name: PKG_NAME,
-                version: PKG_VERSION
-            },
-            datasources: this.writeDatasources(),
-            dataviews: this.writeDataviews(),
-            properties: this.writeProperties()
-        };
-    };
-    return DDLUpgrade;
-}());
-function upgrade(ddl, baseUrl, wuid, toLowerCase, dermatologyJson) {
-    if (toLowerCase === void 0) { toLowerCase = true; }
-    if (dermatologyJson === void 0) { dermatologyJson = {}; }
-    var ddlUp = new DDLUpgrade(ddl, baseUrl, wuid, toLowerCase);
-    var retVal = ddlUp.write();
-    retVal.properties = upgrade$1(retVal, dermatologyJson);
-    return retVal;
-}
-
-var args = process.argv.slice(2);
-switch (args[0]) {
-    case "--echo":
-        process.stdout.write(args[1]);
-        break;
-    case "--schema":
-        process.stdout.write(JSON.stringify(ddl2Schema));
-        break;
-    case "--upgrade":
-    case "--upgradeNoLower":
-        var srcPath = args[1];
-        var destPath_1 = args[2];
-        var baseUrl_1 = args[3];
-        var wuid_1 = args[4];
-        var layoutPath = args[5];
-        if (srcPath && destPath_1 && srcPath !== destPath_1) {
-            var layoutJson_1 = {};
-            if (layoutPath) {
-                try {
-                    layoutJson_1 = JSON.parse(fs__namespace.readFileSync(layoutPath).toString());
-                }
-                catch (e) {
-                    console.error(e);
-                }
-            }
-            fs__namespace.readFile(srcPath, "utf8", function (err, data) {
-                if (err)
-                    throw err;
-                var ddl2 = upgrade(JSON.parse(data), baseUrl_1 || "http://localhost:8010", wuid_1 || "WUID", args[0] === "--upgrade", layoutJson_1);
-                fs__namespace.writeFile(destPath_1, JSON.stringify(ddl2), function (err) {
-                    if (err)
-                        throw err;
-                    console.info("complete");
-                });
-            });
-        }
-        break;
-    case "--help":
-        break;
-    default:
-        process.stdout.write("\nUsage:  <command>\n\nwhere <command> is one of:\n    --schema:  output DDL2 schmea.\n    --upgrade ddl1 [baseUrl wuid [layout]]:  updgrade ddl and layout version 1 to ddl version 2.\n    --upgradeNoLower ddl1 [baseUrl wuid [layout]]:  updgrade ddl and layout version 1 to ddl version 2 without changing field IDs upper/lower casing.\n    --help:  this message.\n");
-}
-//# sourceMappingURL=cli.js.map