@accordproject/concerto-util 4.0.0-alpha.2 → 4.0.0-beta.1

package/dist/loaders/compositefileloader.js

@@ -30,14 +30,14 @@ class CompositeFileLoader {
     }
     /**
      * Adds a FileLoader implemenetation to the FileLoader
-     * @param {*} fileLoader - The script to add to the ScriptManager
+     * @param fileLoader - The script to add to the ScriptManager
      */
     addFileLoader(fileLoader) {
         this.fileLoaders.push(fileLoader);
     }
     /**
      * Get the array of FileLoader instances
-     * @return {*} The FileLoader registered
+     * @return The FileLoader registered
      * @private
      */
     getFileLoaders() {
@@ -51,8 +51,8 @@ class CompositeFileLoader {
     }
     /**
      * Returns true if this ModelLoader can process the URL
-     * @param {string} url - the URL
-     * @return {boolean} true if this ModelLoader accepts the URL
+     * @param url - the URL
+     * @return true if this ModelLoader accepts the URL
      * @abstract
      */
     accepts(url) {
@@ -66,9 +66,9 @@ class CompositeFileLoader {
     }
     /**
      * Load a File from a URL and return it
-     * @param {string} url - the url to get
-     * @param {object} options - additional options
-     * @return {Promise} a promise to the File
+     * @param url - the url to get
+     * @param options - additional options
+     * @return a promise to the File
      */
     load(url, options) {
         for (let n = 0; n < this.fileLoaders.length; n++) {
@@ -81,4 +81,3 @@ class CompositeFileLoader {
     }
 }
 module.exports = CompositeFileLoader;
-//# sourceMappingURL=compositefileloader.js.map

package/dist/loaders/defaultfileloader.d.ts

@@ -1,4 +1,4 @@
-export = DefaultFileLoader;
+import CompositeFileLoader = require('./compositefileloader');
 /**
  * <p>
  * A default CompositeFileLoader implementation which supports
@@ -9,11 +9,11 @@ export = DefaultFileLoader;
  * @see See {@link CompositeFileLoader}
  * @memberof module:concerto-util
  */
-declare class DefaultFileLoader extends CompositeFileLoader {
+declare class DefaultFileLoader<T> extends CompositeFileLoader<T> {
     /**
      * Create the DefaultFileLoader.
-     * @param {*} processFile - a function to apply to the content of the file
+     * @param processFile - a function to apply to the content of the file
      */
-    constructor(processFile: any);
+    constructor(processFile: (name: string, text: string) => T);
 }
-import CompositeFileLoader = require("./compositefileloader");
+export = DefaultFileLoader;

package/dist/loaders/defaultfileloader.js

@@ -12,9 +12,9 @@
  * limitations under the License.
  */
 'use strict';
-const CompositeFileLoader = require('./compositefileloader');
-const HTTPFileLoader = require('./httpfileloader');
-const GitHubFileLoader = require('./githubfileloader');
+const CompositeFileLoader = require("./compositefileloader");
+const HTTPFileLoader = require("./httpfileloader");
+const GitHubFileLoader = require("./githubfileloader");
 /**
  * <p>
  * A default CompositeFileLoader implementation which supports
@@ -28,7 +28,7 @@ const GitHubFileLoader = require('./githubfileloader');
 class DefaultFileLoader extends CompositeFileLoader {
     /**
      * Create the DefaultFileLoader.
-     * @param {*} processFile - a function to apply to the content of the file
+     * @param processFile - a function to apply to the content of the file
      */
     constructor(processFile) {
         super();
@@ -39,4 +39,3 @@ class DefaultFileLoader extends CompositeFileLoader {
     }
 }
 module.exports = DefaultFileLoader;
-//# sourceMappingURL=defaultfileloader.js.map

package/dist/loaders/fileloader.d.ts

@@ -0,0 +1,4 @@
+export interface FileLoader<T> {
+    accepts(url: string): boolean;
+    load(url: string, options?: RequestInit): Promise<T>;
+}

package/dist/loaders/fileloader.js

@@ -0,0 +1,15 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/loaders/githubfileloader.d.ts

@@ -1,4 +1,4 @@
-export = GitHubFileLoader;
+import HTTPFileLoader = require('./httpfileloader');
 /**
  * Loads Files from an external source, such as a URL.
  *
@@ -6,6 +6,25 @@ export = GitHubFileLoader;
  * @private
  * @memberof module:concerto-util
  */
-declare class GitHubFileLoader extends HTTPFileLoader {
+declare class GitHubFileLoader<T> extends HTTPFileLoader<T> {
+    /**
+     * Create the GitHubFileLoader.
+     * @param processFile - a function to apply to the content of the file
+     */
+    constructor(processFile: (name: string, text: string) => T);
+    /**
+     * Returns true if this ModelLoader can process the URL
+     * @param url - the URL
+     * @return true if this ModelLoader accepts the URL
+     * @abstract
+     */
+    accepts(url: string): boolean;
+    /**
+     * Load a File from a URL and return it
+     * @param url - the url to get
+     * @param options - additional options
+     * @return a promise to the File
+     */
+    load(url: string, options?: RequestInit): Promise<T>;
 }
-import HTTPFileLoader = require("./httpfileloader");
+export = GitHubFileLoader;

package/dist/loaders/githubfileloader.js

@@ -12,7 +12,7 @@
  * limitations under the License.
  */
 'use strict';
-const HTTPFileLoader = require('./httpfileloader');
+const HTTPFileLoader = require("./httpfileloader");
 /**
  * Loads Files from an external source, such as a URL.
  *
@@ -23,15 +23,15 @@ const HTTPFileLoader = require('./httpfileloader');
 class GitHubFileLoader extends HTTPFileLoader {
     /**
      * Create the GitHubFileLoader.
-     * @param {*} processFile - a function to apply to the content of the file
+     * @param processFile - a function to apply to the content of the file
      */
     constructor(processFile) {
         super(processFile);
     }
     /**
      * Returns true if this ModelLoader can process the URL
-     * @param {string} url - the URL
-     * @return {boolean} true if this ModelLoader accepts the URL
+     * @param url - the URL
+     * @return true if this ModelLoader accepts the URL
      * @abstract
      */
     accepts(url) {
@@ -39,9 +39,9 @@ class GitHubFileLoader extends HTTPFileLoader {
     }
     /**
      * Load a File from a URL and return it
-     * @param {string} url - the url to get
-     * @param {object} options - additional options
-     * @return {Promise} a promise to the File
+     * @param url - the url to get
+     * @param options - additional options
+     * @return a promise to the File
      */
     load(url, options) {
         const rewrittenUrl = 'https://raw.githubusercontent.com/' + url.substring(9);
@@ -50,4 +50,3 @@ class GitHubFileLoader extends HTTPFileLoader {
     }
 }
 module.exports = GitHubFileLoader;
-//# sourceMappingURL=githubfileloader.js.map

package/dist/loaders/httpfileloader.d.ts

@@ -1,29 +1,30 @@
-export = HTTPFileLoader;
+import type { FileLoader } from './fileloader';
 /**
  * Loads Files from an HTTP(S) URL using fetch.
  * @class
  * @private
  * @memberof module:concerto-util
  */
-declare class HTTPFileLoader {
+declare class HTTPFileLoader<T> implements FileLoader<T> {
+    processFile: (name: string, text: string) => T;
     /**
      * Create the HTTPFileLoader.
-     * @param {*} processFile - a function to apply to the content of the file
+     * @param processFile - a function to apply to the content of the file
      */
-    constructor(processFile: any);
-    processFile: any;
+    constructor(processFile: (name: string, text: string) => T);
     /**
      * Returns true if this ModelLoader can process the URL
-     * @param {string} url - the URL
-     * @return {boolean} true if this ModelLoader accepts the URL
+     * @param url - the URL
+     * @return true if this ModelLoader accepts the URL
      * @abstract
      */
     accepts(url: string): boolean;
     /**
      * Load a text File from a URL and return it
-     * @param {string} requestUrl - the url to get
-     * @param {object} options - additional options
-     * @return {Promise} a promise to the File
+     * @param requestUrl - the url to get
+     * @param options - additional options
+     * @return a promise to the File
      */
-    load(requestUrl: string, options: object): Promise<any>;
+    load(requestUrl: string, options?: RequestInit): Promise<T>;
 }
+export = HTTPFileLoader;

package/dist/loaders/httpfileloader.js

@@ -12,6 +12,7 @@
  * limitations under the License.
  */
 'use strict';
+const debug = require('debug')('concerto:HTTPFileLoader');
 /**
  * Loads Files from an HTTP(S) URL using fetch.
  * @class
@@ -21,15 +22,15 @@
 class HTTPFileLoader {
     /**
      * Create the HTTPFileLoader.
-     * @param {*} processFile - a function to apply to the content of the file
+     * @param processFile - a function to apply to the content of the file
      */
     constructor(processFile) {
         this.processFile = processFile;
     }
     /**
      * Returns true if this ModelLoader can process the URL
-     * @param {string} url - the URL
-     * @return {boolean} true if this ModelLoader accepts the URL
+     * @param url - the URL
+     * @return true if this ModelLoader accepts the URL
      * @abstract
      */
     accepts(url) {
@@ -37,9 +38,9 @@ class HTTPFileLoader {
     }
     /**
      * Load a text File from a URL and return it
-     * @param {string} requestUrl - the url to get
-     * @param {object} options - additional options
-     * @return {Promise} a promise to the File
+     * @param requestUrl - the url to get
+     * @param options - additional options
+     * @return a promise to the File
      */
     async load(requestUrl, options) {
         if (!options) {
@@ -50,6 +51,7 @@ class HTTPFileLoader {
                 }
             };
         }
+        debug('loading', requestUrl);
         const response = await fetch(requestUrl, options);
         if (!response.ok) {
             throw new Error(`HTTP request failed with status: ${response.status}`);
@@ -63,4 +65,3 @@ class HTTPFileLoader {
     }
 }
 module.exports = HTTPFileLoader;
-//# sourceMappingURL=httpfileloader.js.map

package/dist/logger.d.ts

@@ -1,106 +1,86 @@
-export = Logger;
+/**
+ * Default levels for the npm configuration.
+ */
+declare const levels: Record<string, number>;
+/**
+* The default transport for logging at multiple levels to the console
+* @param level - the required log level. e.g. error, warn, info, debug, etc.
+* @param args - the input obj to prettify
+*/
+type LogLevel = keyof typeof levels;
+type Transport = Partial<Record<LogLevel, (...args: unknown[]) => void>>;
 /**
  * A utility class with static function that print to the console
- * @private
  */
 declare class Logger {
+    static level: string;
+    static transports: Transport[];
     /**
     * A reusable function for logging at multiple levels
-    * @param {string} level - the required log level. e.g. error, warn, info, debug, etc.
-    * @param {any} obj - the input obj to prettify
-    * @returns {void} -
-    * @private
+    * @param level - the required log level. e.g. error, warn, info, debug, etc.
+    * @param args - the input obj to prettify
     */
-    private static dispatch;
+    static dispatch(level: LogLevel, ...args: unknown[]): void;
     /**
     * Add a custom transport for logging
-    * @param {Object} transport - The transport object should have function for the usual logging operations e.g. error, warn, info, debug, etc.
-    * @returns {void} -
-    * @private
+    * @param transport - The transport object should have function for the usual logging operations e.g. error, warn, info, debug, etc.
     */
-    private static add;
+    static add(transport: Transport): void;
     /**
      * Write an error statement to the console.
      *
      * Prints to `stderr` with newline.
-     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
-     * @param {any} args -
-     * @returns {void} -
-     * @private
+     * @param args - args
      */
-    private static error;
+    static error(...args: unknown[]): void;
     /**
      * Write a warning statement to the console.
      *
      * Prints to `stderr` with newline.
-     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
-     * @param {any} args -
-     * @returns {void} -
-     * @private
+     * @param args - args
      */
-    private static warn;
+    static warn(...args: unknown[]): void;
     /**
      * Write an info statement to the console.
      *
      * Prints to `stdout` with newline.
-     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
-     * @param {any} args -
-     * @returns {void} -
-     * @private
+     * @param args - args
      */
-    private static info;
+    static info(...args: unknown[]): void;
     /**
      * Write an info statement to the console. Alias for `logger.log`
      *
      * Prints to `stdout` with newline.
-     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
-     * @param {any} args -
-     * @returns {void} -
-     * @private
+     * @param args - args
      */
-    private static log;
+    static log(...args: unknown[]): void;
     /**
      * Write an http statement to the console.
      *
      * Prints to `stdout` with newline.
-     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
-     * @param {any} args -
-     * @returns {void} -
-     * @private
+     * @param args - args
      */
-    private static http;
+    static http(...args: unknown[]): void;
     /**
      * Write a verbose log statement to the console.
      *
      * Prints to `stdout` with newline.
-     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
-     * @param {any} args -
-     * @returns {void} -
-     * @private
+     * @param args - args
      */
-    private static verbose;
+    static verbose(...args: unknown[]): void;
     /**
      * Write a debug statement to the console.
      *
      * Prints to `stdout` with newline.
-     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
-     * @param {any} args -
-     * @returns {void} -
-     * @private
+     * @param args - args
      */
-    private static debug;
+    static debug(...args: unknown[]): void;
     /**
      * Write a silly level statement to the console.
      *
      * Prints to `stdout` with newline.
-     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
-     * @param {any} args -
-     * @returns {void} -
-     * @private
+     * @param args - args
      */
-    private static silly;
-}
-declare namespace Logger {
-    let level: string;
-    let transports: {}[];
+    static silly(...args: unknown[]): void;
 }
+export = Logger;

package/dist/logger.js

@@ -16,7 +16,6 @@
 /* eslint-disable no-use-before-define */
 /**
  * Default levels for the npm configuration.
- * @type {Object}
  */
 const levels = {
     error: 0,
@@ -30,23 +29,15 @@ const levels = {
 const timestamp = () => (new Date()).toLocaleTimeString();
 /**
 * Helper function to format JSON objects
-* @param {any} obj - the input obj to prettify
-* @returns {any} - the prettified object
-* @private
+* @param obj - the input obj to prettify
+* @returns - the prettified object
 */
 const prettifyJson = (obj) => {
     return obj;
 };
-/**
-* The default transport for logging at multiple levels to the console
-* @param {string} level - the required log level. e.g. error, warn, info, debug, etc.
-* @param {any} obj - the input obj to prettify
-* @returns {void} -
-* @private
-*/
 const defaultTransportShim = (level, ...args) => {
     let mutatedLevel = level;
-    let data = args;
+    const data = args;
     let first = data.shift();
     // Flatten log object
     if (first && typeof first === 'object' && first.level && first.message) {
@@ -69,19 +60,17 @@ const defaultTransportShim = (level, ...args) => {
 };
 const defaultTransport = {};
 Object.keys(levels).forEach(level => {
-    defaultTransport[level] = (...args) => defaultTransportShim(level, ...args);
+    const typedLevel = level;
+    defaultTransport[typedLevel] = (...args) => defaultTransportShim(typedLevel, ...args);
 });
 /**
  * A utility class with static function that print to the console
- * @private
  */
 class Logger {
     /**
     * A reusable function for logging at multiple levels
-    * @param {string} level - the required log level. e.g. error, warn, info, debug, etc.
-    * @param {any} obj - the input obj to prettify
-    * @returns {void} -
-    * @private
+    * @param level - the required log level. e.g. error, warn, info, debug, etc.
+    * @param args - the input obj to prettify
     */
     static dispatch(level, ...args) {
         if (levels[level] > levels[this.level]) {
@@ -95,9 +84,7 @@ class Logger {
     }
     /**
     * Add a custom transport for logging
-    * @param {Object} transport - The transport object should have function for the usual logging operations e.g. error, warn, info, debug, etc.
-    * @returns {void} -
-    * @private
+    * @param transport - The transport object should have function for the usual logging operations e.g. error, warn, info, debug, etc.
     */
     static add(transport) {
         this.transports.push(transport);
@@ -106,86 +93,59 @@ class Logger {
      * Write an error statement to the console.
      *
      * Prints to `stderr` with newline.
-     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
-     * @param {any} args -
-     * @returns {void} -
-     * @private
+     * @param args - args
      */
-    static error(...args) { return this.dispatch('error', ...args); }
+    static error(...args) { this.dispatch('error', ...args); }
     /**
      * Write a warning statement to the console.
      *
      * Prints to `stderr` with newline.
-     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
-     * @param {any} args -
-     * @returns {void} -
-     * @private
+     * @param args - args
      */
-    static warn(...args) { return this.dispatch('warn', ...args); }
+    static warn(...args) { this.dispatch('warn', ...args); }
     /**
      * Write an info statement to the console.
      *
      * Prints to `stdout` with newline.
-     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
-     * @param {any} args -
-     * @returns {void} -
-     * @private
+     * @param args - args
      */
-    static info(...args) { return this.dispatch('info', ...args); }
+    static info(...args) { this.dispatch('info', ...args); }
     /**
      * Write an info statement to the console. Alias for `logger.log`
      *
      * Prints to `stdout` with newline.
-     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
-     * @param {any} args -
-     * @returns {void} -
-     * @private
+     * @param args - args
      */
-    static log(...args) { return this.info(...args); }
+    static log(...args) { this.info(...args); }
     /**
      * Write an http statement to the console.
      *
      * Prints to `stdout` with newline.
-     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
-     * @param {any} args -
-     * @returns {void} -
-     * @private
+     * @param args - args
      */
-    static http(...args) { return this.dispatch('http', ...args); }
+    static http(...args) { this.dispatch('http', ...args); }
     /**
      * Write a verbose log statement to the console.
      *
      * Prints to `stdout` with newline.
-     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
-     * @param {any} args -
-     * @returns {void} -
-     * @private
+     * @param args - args
      */
-    static verbose(...args) { return this.dispatch('verbose', ...args); }
+    static verbose(...args) { this.dispatch('verbose', ...args); }
     /**
      * Write a debug statement to the console.
      *
      * Prints to `stdout` with newline.
-     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
-     * @param {any} args -
-     * @returns {void} -
-     * @private
+     * @param args - args
      */
-    static debug(...args) { return this.dispatch('debug', ...args); }
+    static debug(...args) { this.dispatch('debug', ...args); }
     /**
      * Write a silly level statement to the console.
      *
      * Prints to `stdout` with newline.
-     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
-     * @param {any} args -
-     * @returns {void} -
-     * @private
+     * @param args - args
      */
-    static silly(...args) { return this.dispatch('silly', ...args); }
+    static silly(...args) { this.dispatch('silly', ...args); }
 }
-// Set the default logging level
 Logger.level = 'info';
-// A list of user-provided logging tranports
 Logger.transports = [defaultTransport];
 module.exports = Logger;
-//# sourceMappingURL=logger.js.map

package/dist/modelwriter.d.ts

@@ -1,7 +1,15 @@
 /**
  * Writes a set of model files to disk
- * @param {*} files - the set of files to write, with names and whether they are external
- * @param {string} path - a path to the directory where to write the files
- * @param {*} options - a set of options
+ * @param files - the set of files to write, with names and whether they are external
+ * @param path - a path to the directory where to write the files
+ * @param options - a set of options
  */
-export function writeModelsToFileSystem(files: any, path: string, options?: any): void;
+export interface WritableModelFile {
+    fileName: string;
+    definitions: string;
+    external?: boolean;
+}
+export interface WriteModelsOptions {
+    includeExternalModels?: boolean;
+}
+export declare function writeModelsToFileSystem(files: WritableModelFile[], path: string, options?: WriteModelsOptions): void;