@uwdata/mosaic-spec 0.7.0 → 0.8.0

package/dist/types/spec/marks/Vector.d.ts

@@ -0,0 +1,99 @@
+import { ParamRef } from '../Param.js';
+import { FrameAnchor } from '../PlotTypes.js';
+import { ChannelValue, ChannelValueSpec, MarkData, MarkOptions } from './Marks.js';
+/**
+ * The built-in vector shape implementations; one of:
+ *
+ * - *arrow* - a straight line with an open arrowhead at the end (↑)
+ * - *spike* - an isosceles triangle with a flat base (▲)
+ */
+export type VectorShapeName = 'arrow' | 'spike';
+/** How to draw a vector: either a named shape or a custom implementation. */
+export type VectorShape = VectorShapeName;
+/** Options for the vector mark. */
+export interface VectorOptions extends MarkOptions {
+    /**
+     * The horizontal position of the vector’s anchor point; an optional channel
+     * bound to the *x* scale. Default depends on the **frameAnchor**.
+     */
+    x?: ChannelValueSpec;
+    /**
+     * The vertical position of the vector’s anchor point; an optional channel
+     * bound to the *y* scale. Default depends on the **frameAnchor**.
+     */
+    y?: ChannelValueSpec;
+    /**
+     * The vector shape’s radius, such as half the width of the *arrow*’s head or
+     * the *spike*’s base; a constant number in pixels. Defaults to 3.5 pixels.
+     */
+    r?: number | ParamRef;
+    /**
+     * The vector’s length; either an optional channel bound to the *length* scale
+     * or a constant number in pixels. Defaults to 12 pixels.
+     */
+    length?: ChannelValueSpec;
+    /**
+     * The vector’s orientation (rotation angle); either a constant number in
+     * degrees clockwise, or an optional channel (with no associated scale).
+     * Defaults to 0 degrees with the vector pointing up.
+     */
+    rotate?: ChannelValue;
+    /** The shape of the vector; a constant. Defaults to *arrow*. */
+    shape?: VectorShape | ParamRef;
+    /**
+     * The vector’s position along its orientation relative to its anchor point; a
+     * constant. Assuming a default **rotate** angle of 0°, one of:
+     *
+     * - *start* - from [*x*, *y*] to [*x*, *y* - *l*]
+     * - *middle* (default) - from [*x*, *y* + *l* / 2] to [*x*, *y* - *l* / 2]
+     * - *end* - from [*x*, *y* + *l*] to [*x*, *y*]
+     *
+     * where [*x*, *y*] is the vector’s anchor point and *l* is the vector’s
+     * (possibly scaled) length in pixels.
+     */
+    anchor?: 'start' | 'middle' | 'end' | ParamRef;
+    /**
+     * The vector’s frame anchor, to default **x** and **y** relative to the
+     * frame; a constant representing one of the frame corners (*top-left*,
+     * *top-right*, *bottom-right*, *bottom-left*), sides (*top*, *right*,
+     * *bottom*, *left*), or *middle* (default). Has no effect if both **x**
+     * and **y** are specified.
+     */
+    frameAnchor?: FrameAnchor | ParamRef;
+}
+/** The vector mark. */
+export interface Vector extends MarkData, VectorOptions {
+    /**
+     * A vector mark.
+     *
+     * If none of **frameAnchor**, **x**, and **y** are specified, then **x** and
+     * **y** default to accessors assuming that *data* contains tuples [[*x₀*,
+     * *y₀*], [*x₁*, *y₁*], [*x₂*, *y₂*], …]
+     */
+    mark: 'vector';
+}
+/** The vectorX mark. */
+export interface VectorX extends MarkData, VectorOptions {
+    /**
+     * Like vector, but **x** instead defaults to the identity function and **y**
+     * defaults to null, assuming that *data* is an array of numbers [*x₀*, *x₁*,
+     * *x₂*, …].
+     */
+    mark: 'vectorX';
+}
+/** The vectorY mark. */
+export interface VectorY extends MarkData, VectorOptions {
+    /**
+     * Like vector, but **y** instead defaults to the identity function and **x**
+     * defaults to null, assuming that *data* is an array of numbers [*y₀*, *y₁*,
+     * *y₂*, …].
+     */
+    mark: 'vectorY';
+}
+/** The spike mark. */
+export interface Spike extends MarkData, VectorOptions {
+    /**
+     * Like vector, but with default *options* suitable for drawing a spike map.
+     */
+    mark: 'spike';
+}

package/dist/types/util.d.ts

@@ -0,0 +1,12 @@
+export function paramRef(value: any): any;
+export function paramStr(value: any): any;
+export function toParamRef(name: any): string;
+export function toArray(value: any): any[];
+export function isArray(value: any): boolean;
+export function isObject(value: any): boolean;
+export function isNumber(value: any): boolean;
+export function isNumberOrString(value: any): boolean;
+export function isString(value: any): boolean;
+export function isFunction(value: any): boolean;
+export function error(message: any, data: any): void;
+export function isoparse(string: any, fallback: any): any;

package/jsconfig.json

@@ -0,0 +1,10 @@
+{
+  "include": ["src/**/*", "../../specs/ts/*.ts"],
+  "compilerOptions": {
+    "checkJs": true,
+    "noEmit": true,
+    "noImplicitAny": false,
+    "module": "node16",
+    "skipLibCheck": true
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uwdata/mosaic-spec",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Declarative specification of Mosaic-powered applications.",
   "keywords": [
     "mosaic",
@@ -16,22 +16,29 @@
   "module": "src/index.js",
   "jsdelivr": "dist/mosaic-spec.min.js",
   "unpkg": "dist/mosaic-spec.min.js",
+  "types": "dist/types/index.d.ts",
   "repository": {
     "type": "git",
     "url": "https://github.com/uwdata/mosaic.git"
   },
   "scripts": {
     "prebuild": "rimraf dist && mkdir dist",
-    "build": "node ../../esbuild.js mosaic-spec",
-    "lint": "eslint src test --ext .js",
-    "test": "mocha 'test/**/*-test.js'",
+    "build": "npm run types && node ../../esbuild.js mosaic-spec",
+    "lint": "eslint src test",
+    "types": "tsc -p tsconfig.json && npm run schema",
+    "schema": "ts-json-schema-generator -f tsconfig.json -p src/spec/Spec.ts -t Spec --no-type-check --no-ref-encode --functions hide > dist/mosaic-schema.json",
+    "pretest": "npm run prebuild && npm run types",
+    "test": "mocha 'test/**/*-test.js' && tsc -p jsconfig.json",
     "prepublishOnly": "npm run test && npm run lint && npm run build"
   },
   "dependencies": {
-    "@uwdata/mosaic-core": "^0.7.0",
-    "@uwdata/mosaic-sql": "^0.7.0",
-    "@uwdata/vgplot": "^0.7.0",
-    "isoformat": "^0.2.1"
+    "@uwdata/mosaic-core": "^0.8.0",
+    "@uwdata/mosaic-sql": "^0.8.0",
+    "@uwdata/vgplot": "^0.8.0",
+    "ts-json-schema-generator": "^2.1.1"
   },
-  "gitHead": "4680b922f15579b7b527f31507ed71a12230ec35"
+  "devDependencies": {
+    "ajv": "^8.13.0"
+  },
+  "gitHead": "a24b4c9f7dfa1c38c6af96ec17e075326c1af9b0"
 }

package/src/ast/ASTNode.js

@@ -1,18 +1,39 @@
+/**
+ * Abstract base class for Mosaic spec AST nodes.
+ */
 export class ASTNode {
   constructor(type, children = null) {
+    /** @type {string} */
     this.type = type;
+    /** @type {ASTNode[] | null} */
     this.children = children;
   }
 
-  instantiate(/* ctx */) {
+  /**
+   * Instantiate this AST node to use in a live web application.
+   * @param {import('../ast-to-dom.js').InstantiateContext} ctx The instantiation context.
+   * @returns {*} The instantiated value of this node.
+   */
+  instantiate(ctx) { // eslint-disable-line no-unused-vars
+    // @ts-ignore
     throw Error('instantiate not implemented');
   }
 
-  codegen(/* ctx */) {
+  /**
+   * Generate ESM code for this AST node.
+   * @param {import('../ast-to-esm.js').CodegenContext} ctx The code generator context.
+   * @returns {string|void} The generated ESM code for the node.
+   */
+  codegen(ctx) { // eslint-disable-line no-unused-vars
+    // @ts-ignore
     return Error('codegen not implemented');
   }
 
+  /**
+   * @returns {*} This AST node in JSON specification format.
+   */
   toJSON() {
+    // @ts-ignore
     return Error('toJSON not implemented');
   }
 }

package/src/ast/DataNode.js

@@ -10,6 +10,7 @@ export const CSV_DATA = 'csv';
 export const JSON_DATA = 'json';
 export const SPATIAL_DATA = 'spatial';
 
+// @ts-ignore
 const dataFormats = new Map([
   [TABLE_DATA, parseTableData],
   [PARQUET_DATA, parseParquetData],
@@ -18,16 +19,40 @@ const dataFormats = new Map([
   [SPATIAL_DATA, parseSpatialData]
 ]);
 
+/**
+ * Parse a data definition spec.
+ * @param {string} name The name of the dataset
+ * @param {import('../spec/Data.js').DataDefinition} spec The data definition spec.
+ * @param {import('../parse-spec.js').ParseContext} ctx The parser context.
+ * @returns {DataNode} a parsed data definition AST node
+ */
 export function parseData(name, spec, ctx) {
-  spec = resolveDataSpec(spec);
-  if (dataFormats.has(spec.type)) {
-    const parse = dataFormats.get(spec.type);
-    return parse(name, spec, ctx);
+  const def = resolveDataSpec(spec);
+  if (dataFormats.has(def.type)) {
+    const parse = dataFormats.get(def.type);
+    return parse(name, def, ctx);
   } else {
     ctx.error(`Unrecognized data format type.`, spec);
   }
 }
 
+function resolveDataSpec(spec) {
+  if (isArray(spec)) spec = { type: 'json', data: spec };
+  if (isString(spec)) spec = { type: 'table', query: spec };
+  return { ...spec, type: inferType(spec) };
+}
+
+function inferType(spec) {
+  return spec.type
+    || fileExtension(spec.file)
+    || 'table';
+}
+
+function fileExtension(file) {
+  const idx = file?.lastIndexOf('.');
+  return idx > 0 ? file.slice(idx + 1) : null;
+}
+
 function parseTableData(name, spec, ctx) {
   // eslint-disable-next-line no-unused-vars
   const { query, type, ...options } = spec;
@@ -61,23 +86,6 @@ function parseSpatialData(name, spec, ctx) {
   return new SpatialDataNode(name, file, parseOptions(options, ctx));
 }
 
-function resolveDataSpec(spec) {
-  if (isArray(spec)) spec = { type: 'json', data: spec };
-  if (isString(spec)) spec = { type: 'table', query: spec };
-  return { ...spec, type: inferType(spec) };
-}
-
-function inferType(spec) {
-  return spec.type
-    || fileExtension(spec.file)
-    || 'table';
-}
-
-function fileExtension(file) {
-  const idx = file?.lastIndexOf('.');
-  return idx > 0 ? file.slice(idx + 1) : null;
-}
-
 function resolveFileURL(file, baseURL) {
   return baseURL ? new URL(file, baseURL).toString() : file;
 }
@@ -100,19 +108,39 @@ export class QueryDataNode extends DataNode {
     super(name, format);
   }
 
+  /**
+   * Instantiate a table creation query.
+   * @param {import('../ast-to-dom.js').InstantiateContext} ctx The instantiation context.
+   * @returns {string|void} The instantiated query.
+   */
   instantiateQuery(ctx) {
     ctx.error('instantiateQuery not implemented');
   }
 
+  /**
+   * Code generate a table creation query.
+   * @param {import('../ast-to-esm.js').CodegenContext} ctx The code generator context.
+   * @returns {string|void} The generated query code.
+   */
   codegenQuery(ctx) {
     ctx.error('codegenQuery not implemented');
   }
 
+  /**
+   * Instantiate this AST node to use in a live web application.
+   * @param {import('../ast-to-dom.js').InstantiateContext} ctx The instantiation context.
+   * @returns {*} The instantiated value of this node.
+   */
   instantiate(ctx) {
     const query = this.instantiateQuery(ctx);
     if (query) return query;
   }
 
+  /**
+   * Generate ESM code for this AST node.
+   * @param {import('../ast-to-esm.js').CodegenContext} ctx The code generator context.
+   * @returns {string|void} The generated ESM code for the node.
+   */
   codegen(ctx) {
     const query = this.codegenQuery(ctx);
     if (query) return query;
@@ -126,6 +154,11 @@ export class TableDataNode extends QueryDataNode {
     this.options = options;
   }
 
+  /**
+   * Instantiate a table creation query.
+   * @param {import('../ast-to-dom.js').InstantiateContext} ctx The instantiation context.
+   * @returns {string|void} The instantiated query.
+   */
   instantiateQuery(ctx) {
     const { name, query, options } = this;
     if (query) {
@@ -133,6 +166,11 @@ export class TableDataNode extends QueryDataNode {
     }
   }
 
+  /**
+   * Code generate a table creation query.
+   * @param {import('../ast-to-esm.js').CodegenContext} ctx The code generator context.
+   * @returns {string|void} The generated query code.
+   */
   codegenQuery(ctx) {
     const { name, query, options } = this;
     if (query) {
@@ -154,6 +192,11 @@ export class FileDataNode extends QueryDataNode {
     this.options = options;
   }
 
+  /**
+   * Instantiate a table creation query.
+   * @param {import('../ast-to-dom.js').InstantiateContext} ctx The instantiation context.
+   * @returns {string|void} The instantiated query.
+   */
   instantiateQuery(ctx) {
     const { name, method, file, options } = this;
     const url = resolveFileURL(file, ctx.baseURL);
@@ -161,6 +204,11 @@ export class FileDataNode extends QueryDataNode {
     return ctx.api[method](name, url, opt);
   }
 
+  /**
+   * Code generate a table creation query.
+   * @param {import('../ast-to-esm.js').CodegenContext} ctx The code generator context.
+   * @returns {string|void} The generated query code.
+   */
   codegenQuery(ctx) {
     const { name, method, file, options } = this;
     const url = resolveFileURL(file, ctx.baseURL);
@@ -205,11 +253,21 @@ export class LiteralJSONDataNode extends QueryDataNode {
     this.options = options;
   }
 
+  /**
+   * Instantiate a table creation query.
+   * @param {import('../ast-to-dom.js').InstantiateContext} ctx The instantiation context.
+   * @returns {string|void} The instantiated query.
+   */
   instantiateQuery(ctx) {
     const { name, data, options } = this;
     return ctx.api.loadObjects(name, data, options.instantiate(ctx));
   }
 
+  /**
+   * Code generate a table creation query.
+   * @param {import('../ast-to-esm.js').CodegenContext} ctx The code generator context.
+   * @returns {string|void} The generated query code.
+   */
   codegenQuery(ctx) {
     const { name, data, options } = this;
     const opt = options ? ',' + options.codegen(ctx) : '';

package/src/ast/HSpaceNode.js

@@ -16,7 +16,7 @@ export class HSpaceNode extends ASTNode {
   }
 
   codegen(ctx) {
-    return `${ctx.tab()}${ctx.ns()}${this.type}(${this.value})`;
+    return `${ctx.tab()}${ctx.ns()}${this.type}(${ctx.stringify(this.value)})`;
   }
 
   toJSON() {

package/src/ast/InputNode.js

@@ -18,8 +18,7 @@ export class InputNode extends ASTNode {
   }
 
   instantiate(ctx) {
-    const fn = ctx.api[this.name];
-    return fn(this.options.instantiate(ctx));
+    return ctx.api[this.name](this.options.instantiate(ctx));
   }
 
   codegen(ctx) {

package/src/ast/ParamNode.js

@@ -1,5 +1,4 @@
-import { parse as isoparse } from 'isoformat';
-import { isArray, isObject } from '../util.js';
+import { isArray, isObject, isoparse } from '../util.js';
 import { ASTNode } from './ASTNode.js';
 import { CROSSFILTER, INTERSECT, PARAM, SINGLE, UNION, VALUE } from '../constants.js';
 import { SelectionNode } from './SelectionNode.js';

package/src/ast/PlotAttributeNode.js

@@ -20,8 +20,7 @@ export class PlotAttributeNode extends ASTNode {
 
   instantiate(ctx) {
     const { name, value } = this;
-    const fn = ctx.api[name];
-    return fn(value.instantiate(ctx));
+    return ctx.api[name](value.instantiate(ctx));
   }
 
   codegen(ctx) {

package/src/ast/PlotInteractorNode.js

@@ -18,8 +18,7 @@ export class PlotInteractorNode extends ASTNode {
   }
 
   instantiate(ctx) {
-    const fn = ctx.api[this.name];
-    return fn(this.options.instantiate(ctx));
+    return ctx.api[this.name](this.options.instantiate(ctx));
   }
 
   codegen(ctx) {

package/src/ast/PlotLegendNode.js

@@ -20,8 +20,7 @@ export class PlotLegendNode extends ASTNode {
   }
 
   instantiate(ctx) {
-    const fn = ctx.api[this.key];
-    return fn(this.options.instantiate(ctx));
+    return ctx.api[this.key](this.options.instantiate(ctx));
   }
 
   codegen(ctx) {

package/src/ast/PlotMarkNode.js

@@ -41,9 +41,10 @@ export class PlotMarkNode extends ASTNode {
 
   instantiate(ctx) {
     const { name, data, options } = this;
-    const fn = ctx.api[name];
     const opt = options.instantiate(ctx);
-    return data ? fn(data.instantiate(ctx), opt) : fn(opt);
+    return data
+      ? ctx.api[name](data.instantiate(ctx), opt)
+      : ctx.api[name](opt);
   }
 
   codegen(ctx) {

package/src/ast/TransformNode.js

@@ -41,8 +41,7 @@ export class TransformNode extends ASTNode {
     const { name, args, options } = this;
     const { distinct, orderby, partitionby, rows, range } = options;
 
-    const fn = ctx.api[name];
-    let expr = fn(...args);
+    let expr = ctx.api[name](...args);
     if (distinct) {
       expr = expr.distinct();
     }

package/src/ast/VSpaceNode.js

@@ -16,7 +16,7 @@ export class VSpaceNode extends ASTNode {
   }
 
   codegen(ctx) {
-    return `${ctx.tab()}${ctx.ns()}${this.type}(${this.value})`;
+    return `${ctx.tab()}${ctx.ns()}${this.type}(${ctx.stringify(this.value)})`;
   }
 
   toJSON() {

package/src/ast-to-dom.js

@@ -1,15 +1,21 @@
+import { Param, Selection } from '@uwdata/mosaic-core';
 import { createAPIContext, loadExtension } from '@uwdata/vgplot';
 import { SpecNode } from './ast/SpecNode.js';
 import { resolveExtensions } from './config/extensions.js';
 import { error } from './util.js';
 
 /**
- * Generate running web application (DOM content) for a Mosaic spec AST.
+ * Generate a running web application (DOM content) for a Mosaic spec AST.
  * @param {SpecNode} ast Mosaic AST root node.
  * @param {object} [options] Instantiation options.
  * @param {string} [options.baseURL] The base URL for loading data files.
- * @returns {object} An object with the resulting DOM element, and
- *   a map of named parameters (Param and Selection instances).
+ * @param {any[]} [options.plotDefaults] Array of default plot attributes.
+ * @param {Map<string, Param>} [options.params] A map of predefined Params/Selections.
+ * @returns {Promise<{
+ *   element: HTMLElement | SVGSVGElement;
+*    params: Map<string, Param | Selection>;
+*  }>} A Promise to an object with the resulting
+ *  DOM element, and a map of named parameters (Param and Selection instances).
  */
 export async function astToDOM(ast, options) {
   const { data, params, plotDefaults } = ast;
@@ -33,9 +39,12 @@ export async function astToDOM(ast, options) {
   }
 
   // process param/selection definitions
+  // skip definitions with names already defined
   for (const [name, node] of Object.entries(params)) {
-    const param = node.instantiate(ctx);
-    ctx.activeParams.set(name, param);
+    if (!ctx.activeParams.has(name)) {
+      const param = node.instantiate(ctx);
+      ctx.activeParams.set(name, param);
+    }
   }
 
   return {
@@ -48,12 +57,12 @@ export class InstantiateContext {
   constructor({
     api = createAPIContext(),
     plotDefaults = [],
-    activeParams = new Map,
+    params = new Map,
     baseURL = null
   } = {}) {
     this.api = api;
     this.plotDefaults = plotDefaults;
-    this.activeParams = activeParams;
+    this.activeParams = params;
     this.baseURL = baseURL;
     this.coordinator = api.context.coordinator;
   }

package/src/ast-to-esm.js

@@ -1,22 +1,27 @@
 import { SpecNode } from './ast/SpecNode.js';
 import { resolveExtensions } from './config/extensions.js';
-import { error, isArray, isObject, isString, toParamRef } from './util.js';
+import { error, isArray, isObject, isString, toArray, toParamRef } from './util.js';
 
 /**
  * Generate ESM code for a Mosaic spec AST.
  * @param {SpecNode} ast Mosaic AST root node.
  * @param {object} [options] Code generation options.
- * @param {string} [options.namespace='vg'] The vgplot API namespace object.
  * @param {string} [options.baseURL] The base URL for loading data files.
+ * @param {string} [options.connector] A database connector to initialize.
+ *  Valid values are 'wasm', 'socket', and 'rest'.
+ *  If undefined, no connector code is generated.
+ * @param {string} [options.namespace='vg'] The vgplot API namespace object.
  * @param {number} [options.depth=0] The starting indentation depth.
- * @param {Map<string,string>} [options.imports] A Map of ESM imports to
- *  include in generated code. Keys are packages (e.g., '@uwdata/vgplot')
- *  and values indicate what to import (e.g., '* as vg').
+ * @param {Map<string,string|string[]>} [options.imports] A Map of ESM
+ *  imports to include in generated code. Keys are packages (e.g.,
+ *  '@uwdata/vgplot') and values indicate what to import (e.g., '* as vg').
+ * @param {string|string[]} [options.preamble] Code to include after imports.
  * @returns {string} Generated ESM code using the vgplot API.
  */
-export function astToESM(ast, options) {
+export function astToESM(ast, options = {}) {
   const { root, data, params, plotDefaults } = ast;
-  const ctx = new CodegenContext({ plotDefaults, ...options });
+  const { preamble, ...ctxOptions } = options;
+  const ctx = new CodegenContext({ plotDefaults, ...ctxOptions });
 
   // generate package imports
   const importsCode = [];
@@ -24,10 +29,16 @@ export function astToESM(ast, options) {
     importsCode.push(
       isString(methods)
         ? `import ${methods} from "${pkg}";`
+        // @ts-ignore
         : `import { ${methods.join(', ')} } from "${pkg}";`
     );
   }
 
+  // preamble code comes directly after imports
+  const preambleCode = preamble
+    ? toArray(preamble).map(s => `${ctx.tab()}${s}`)
+    : [];
+
   // generate database connector code
   const connectorCode = [];
   if (ctx.connector) {
@@ -82,6 +93,8 @@ export function astToESM(ast, options) {
   return [
     ...importsCode,
     ...maybeNewline(importsCode),
+    ...preambleCode,
+    ...maybeNewline(preambleCode),
     ...connectorCode,
     ...maybeNewline(connectorCode),
     ...dataCode,
@@ -95,12 +108,26 @@ export function astToESM(ast, options) {
 }
 
 export class CodegenContext {
+  /**
+   * Create a new code generator context.
+   * @param {object} [options] Code generation options.
+   * @param {*} [options.plotDefaults] Default attributes to apply to all plots.
+   * @param {string} [options.baseURL] The base URL for loading data files.
+   * @param {string} [options.connector] A database connector to initialize.
+   *  Valid values are 'wasm', 'socket', and 'rest'.
+   *  If undefined, no connector code is generated.
+   * @param {string} [options.namespace='vg'] The vgplot API namespace object.
+   * @param {number} [options.depth=0] The starting indentation depth.
+   * @param {Map<string,string|string[]>} [options.imports] A Map of ESM
+   *  imports to include in generated code. Keys are packages (e.g.,
+   *  '@uwdata/vgplot') and values indicate what to import (e.g., '* as vg').
+   */
   constructor({
-    plotDefaults = null,
+    plotDefaults = undefined,
     namespace = 'vg',
-    connector = null,
+    connector = undefined,
     imports = new Map([['@uwdata/vgplot', '* as vg']]),
-    baseURL = null,
+    baseURL = undefined,
     depth = 0
   } = {}) {
     this.plotDefaults = plotDefaults;
@@ -113,9 +140,11 @@ export class CodegenContext {
 
   addImport(pkg, method) {
     if (!this.imports.has(pkg)) {
-      this.imports.set(pkg, []);
+      this.imports.set(pkg, [method]);
+    } else {
+      // @ts-ignore
+      this.imports.get(pkg).push(method);
     }
-    this.imports.get(pkg).push(method);
   }
 
   setImports(pkg, all) {

package/src/config/inputs.js

@@ -1,5 +1,6 @@
 /**
  * Set of input widget type names.
+ * @returns {Set<string>}
  */
 export function inputNames(overrides = []) {
   return new Set([