@contrail/cli 3.4.4-alpha.7adb62a → 3.4.4-alpha.e5b7d5d

package/node_modules/csv-parse/lib/index.d.ts

@@ -0,0 +1,283 @@
+// Original definitions in https://github.com/DefinitelyTyped/DefinitelyTyped by: David Muller <https://github.com/davidm77>
+
+/// <reference types="node" />
+
+import * as stream from "stream";
+
+export type Callback = (err: CsvError | undefined, records: any | undefined, info: Info) => void;
+
+export interface Parser extends stream.Transform {}
+
+export class Parser {
+    constructor(options: Options);
+    
+    __push(line: any): any;
+    
+    __write(chars: any, end: any, callback: any): any;
+    
+    readonly options: Options
+    
+    readonly info: Info;
+}
+
+export interface CastingContext {
+    readonly column: number | string;
+    readonly empty_lines: number;
+    readonly error: CsvError;
+    readonly header: boolean;
+    readonly index: number;
+    readonly quoting: boolean;
+    readonly lines: number;
+    readonly records: number;
+    readonly invalid_field_length: number;
+}
+
+export type CastingFunction = (value: string, context: CastingContext) => any;
+
+export type CastingDateFunction = (value: string, context: CastingContext) => Date;
+
+export type ColumnOption = string | undefined | null | false | { name: string };
+
+/*
+Note, could not `extends stream.TransformOptions` because encoding can be
+BufferEncoding and undefined as well as null which is not defined in the
+extended type.
+*/
+export interface Options {
+    /**
+     * If true, the parser will attempt to convert read data types to native types.
+     * @deprecated Use {@link cast}
+     */
+    auto_parse?: boolean | CastingFunction;
+    autoParse?: boolean | CastingFunction;
+    /**
+     * If true, the parser will attempt to convert read data types to dates. It requires the "auto_parse" option.
+     * @deprecated Use {@link cast_date}
+     */
+    auto_parse_date?: boolean | CastingDateFunction;
+    autoParseDate?: boolean | CastingDateFunction;
+    /**
+     * If true, detect and exclude the byte order mark (BOM) from the CSV input if present.
+     */
+    bom?: boolean;
+    /**
+     * If true, the parser will attempt to convert input string to native types.
+     * If a function, receive the value as first argument, a context as second argument and return a new value. More information about the context properties is available below.
+     */
+    cast?: boolean | CastingFunction;
+    /**
+     * If true, the parser will attempt to convert input string to dates.
+     * If a function, receive the value as argument and return a new value. It requires the "auto_parse" option. Be careful, it relies on Date.parse.
+     */
+    cast_date?: boolean | CastingDateFunction;
+    castDate?: boolean | CastingDateFunction;
+    /**
+     * List of fields as an array,
+     * a user defined callback accepting the first line and returning the column names or true if autodiscovered in the first CSV line,
+     * default to null,
+     * affect the result data set in the sense that records will be objects instead of arrays.
+     */
+    columns?: ColumnOption[] | boolean | ((record: any) => ColumnOption[]);
+    /**
+     * Convert values into an array of values when columns are activated and
+     * when multiple columns of the same name are found.
+     */
+    group_columns_by_name?: boolean;
+    groupColumnsByName?: boolean;
+    /**
+     * Treat all the characters after this one as a comment, default to '' (disabled).
+     */
+    comment?: string;
+    /**
+     * Restrict the definition of comments to a full line. Comment characters
+     * defined in the middle of the line are not interpreted as such. The
+     * option require the activation of comments.
+     */
+    comment_no_infix?: boolean;
+    /**
+     * Set the field delimiter. One character only, defaults to comma.
+     */
+    delimiter?: string | string[] | Buffer;
+    /**
+     * Set the source and destination encoding, a value of `null` returns buffer instead of strings.
+     */
+    encoding?: BufferEncoding | undefined;
+    /**
+     * Set the escape character, one character only, defaults to double quotes.
+     */
+    escape?: string | null | false | Buffer;
+    /**
+     * Start handling records from the requested number of records.
+     */
+    from?: number;
+    /**
+     * Start handling records from the requested line number.
+     */
+    from_line?: number;
+    fromLine?: number;
+    /**
+     * Don't interpret delimiters as such in the last field according to the number of fields calculated from the number of columns, the option require the presence of the `column` option when `true`.
+     */
+    ignore_last_delimiters?: boolean | number;
+    /**
+     * Generate two properties `info` and `record` where `info` is a snapshot of the info object at the time the record was created and `record` is the parsed array or object.
+     */
+    info?: boolean;
+    /**
+     * If true, ignore whitespace immediately following the delimiter (i.e. left-trim all fields), defaults to false.
+     * Does not remove whitespace in a quoted field.
+     */
+    ltrim?: boolean;
+    /**
+     * Maximum numer of characters to be contained in the field and line buffers before an exception is raised,
+     * used to guard against a wrong delimiter or record_delimiter,
+     * default to 128000 characters.
+     */
+    max_record_size?: number;
+    maxRecordSize?: number;
+    /**
+     * Name of header-record title to name objects by.
+     */
+    objname?: string;
+    /**
+     * Alter and filter records by executing a user defined function.
+     */
+    on_record?: (record: any, context: CastingContext) => any;
+    onRecord?: (record: any, context: CastingContext) => any;
+    /**
+     * Optional character surrounding a field, one character only, defaults to double quotes.
+     */
+    quote?: string | boolean | Buffer | null;
+    /**
+     * Generate two properties raw and row where raw is the original CSV row content and row is the parsed array or object.
+     */
+    raw?: boolean;
+    /**
+     * Discard inconsistent columns count, default to false.
+     */
+    relax_column_count?: boolean;
+    relaxColumnCount?: boolean;
+    /**
+     * Discard inconsistent columns count when the record contains less fields than expected, default to false.
+     */
+    relax_column_count_less?: boolean;
+    relaxColumnCountLess?: boolean;
+    /**
+     * Discard inconsistent columns count when the record contains more fields than expected, default to false.
+     */
+    relax_column_count_more?: boolean;
+    relaxColumnCountMore?: boolean;
+    /**
+     * Preserve quotes inside unquoted field.
+     */
+    relax_quotes?: boolean;
+    relaxQuotes?: boolean;
+    /**
+     * One or multiple characters used to delimit record rows; defaults to auto discovery if not provided.
+     * Supported auto discovery method are Linux ("\n"), Apple ("\r") and Windows ("\r\n") row delimiters.
+     */
+    record_delimiter?: string | string[] | Buffer | Buffer[];
+    recordDelimiter?: string | string[] | Buffer | Buffer[];
+    /**
+     * If true, ignore whitespace immediately preceding the delimiter (i.e. right-trim all fields), defaults to false.
+     * Does not remove whitespace in a quoted field.
+     */
+    rtrim?: boolean;
+    /**
+     * Dont generate empty values for empty lines.
+     * Defaults to false
+     */
+    skip_empty_lines?: boolean;
+    skipEmptyLines?: boolean;
+    /**
+     * Skip a line with error found inside and directly go process the next line.
+     */
+    skip_records_with_error?: boolean;
+    skipRecordsWithError?: boolean;
+    /**
+     * Don't generate records for lines containing empty column values (column matching /\s*\/), defaults to false.
+     */
+    skip_records_with_empty_values?: boolean;
+    skipRecordsWithEmptyValues?: boolean;
+    /**
+     * Stop handling records after the requested number of records.
+     */
+    to?: number;
+    /**
+     * Stop handling records after the requested line number.
+     */
+    to_line?: number;
+    toLine?: number;
+    /**
+     * If true, ignore whitespace immediately around the delimiter, defaults to false.
+     * Does not remove whitespace in a quoted field.
+     */
+    trim?: boolean;
+}
+
+export interface Info {
+    /**
+     * Count the number of lines being fully commented.
+     */
+    readonly comment_lines: number;
+    /**
+     * Count the number of processed empty lines.
+     */
+    readonly empty_lines: number;
+    /**
+     * The number of lines encountered in the source dataset, start at 1 for the first line.
+     */
+    readonly lines: number;
+    /**
+     * Count the number of processed records.
+     */
+    readonly records: number;
+    /**
+     * Count of the number of processed bytes.
+     */
+    readonly bytes: number;
+    /**
+     * Number of non uniform records when `relax_column_count` is true.
+     */
+    readonly invalid_field_length: number;
+    /**
+     * Normalized verion of `options.columns` when `options.columns` is true, boolean otherwise.
+     */
+    readonly columns: boolean | { name: string }[] | { disabled: true }[];
+}
+
+export type CsvErrorCode = 
+    'CSV_INVALID_OPTION_BOM'
+    | 'CSV_INVALID_OPTION_CAST'
+    | 'CSV_INVALID_OPTION_CAST_DATE'
+    | 'CSV_INVALID_OPTION_COLUMNS'
+    | 'CSV_INVALID_OPTION_GROUP_COLUMNS_BY_NAME'
+    | 'CSV_INVALID_OPTION_COMMENT'
+    | 'CSV_INVALID_OPTION_DELIMITER'
+    | 'CSV_INVALID_OPTION_ON_RECORD'
+    | 'CSV_INVALID_CLOSING_QUOTE'
+    | 'INVALID_OPENING_QUOTE'
+    | 'CSV_INVALID_COLUMN_MAPPING'
+    | 'CSV_INVALID_ARGUMENT'
+    | 'CSV_INVALID_COLUMN_DEFINITION'
+    | 'CSV_MAX_RECORD_SIZE'
+    | 'CSV_NON_TRIMABLE_CHAR_AFTER_CLOSING_QUOTE'
+    | 'CSV_QUOTE_NOT_CLOSED'
+    | 'CSV_RECORD_INCONSISTENT_FIELDS_LENGTH'
+    | 'CSV_RECORD_INCONSISTENT_COLUMNS'
+    | 'CSV_OPTION_COLUMNS_MISSING_NAME'
+
+export class CsvError extends Error {
+    readonly code: CsvErrorCode;
+    [key: string]: any;
+
+    constructor(code: CsvErrorCode, message: string | string[], options?: Options, ...contexts: any[]);
+}
+
+declare function parse(input: Buffer | string, options?: Options, callback?: Callback): Parser;
+declare function parse(input: Buffer | string, callback?: Callback): Parser;
+declare function parse(options?: Options, callback?: Callback): Parser;
+declare function parse(callback?: Callback): Parser;
+
+// export default parse;
+export { parse }

package/node_modules/csv-parse/lib/index.js

@@ -0,0 +1,121 @@
+
+/*
+CSV Parse
+
+Please look at the [project documentation](https://csv.js.org/parse/) for
+additional information.
+*/
+
+import { Transform } from 'stream';
+import {is_object} from './utils/is_object.js';
+import {transform} from './api/index.js';
+import {CsvError} from './api/CsvError.js';
+
+class Parser extends Transform {
+  constructor(opts = {}){
+    super({...{readableObjectMode: true}, ...opts, encoding: null});
+    this.api = transform(opts);
+    this.api.options.on_skip = (err, chunk) => {
+      this.emit('skip', err, chunk);
+    };
+    // Backward compatibility
+    this.state = this.api.state;
+    this.options = this.api.options;
+    this.info = this.api.info;
+  }
+  // Implementation of `Transform._transform`
+  _transform(buf, _, callback){
+    if(this.state.stop === true){
+      return;
+    }
+    const err = this.api.parse(buf, false, (record) => {
+      this.push(record);
+    }, () => {
+      this.push(null);
+      this.end();
+      // Fix #333 and break #410
+      //   ko: api.stream.iterator.coffee
+      //   ko with v21.4.0, ok with node v20.5.1: api.stream.finished # aborted (with generate())
+      //   ko: api.stream.finished # aborted (with Readable)
+      // this.destroy()
+      // Fix #410 and partially break #333
+      //   ok: api.stream.iterator.coffee
+      //   ok: api.stream.finished # aborted (with generate())
+      //   broken: api.stream.finished # aborted (with Readable)
+      this.on('end', this.destroy);
+    });
+    if(err !== undefined){
+      this.state.stop = true;
+    }
+    callback(err);
+  }
+  // Implementation of `Transform._flush`
+  _flush(callback){
+    if(this.state.stop === true){
+      return;
+    }
+    const err = this.api.parse(undefined, true, (record) => {
+      this.push(record);
+    }, () => {
+      this.push(null);
+      this.on('end', this.destroy);
+    });
+    callback(err);
+  }
+}
+
+const parse = function(){
+  let data, options, callback;
+  for(const i in arguments){
+    const argument = arguments[i];
+    const type = typeof argument;
+    if(data === undefined && (typeof argument === 'string' || Buffer.isBuffer(argument))){
+      data = argument;
+    }else if(options === undefined && is_object(argument)){
+      options = argument;
+    }else if(callback === undefined && type === 'function'){
+      callback = argument;
+    }else{
+      throw new CsvError('CSV_INVALID_ARGUMENT', [
+        'Invalid argument:',
+        `got ${JSON.stringify(argument)} at index ${i}`
+      ], options || {});
+    }
+  }
+  const parser = new Parser(options);
+  if(callback){
+    const records = options === undefined || options.objname === undefined ? [] : {};
+    parser.on('readable', function(){
+      let record;
+      while((record = this.read()) !== null){
+        if(options === undefined || options.objname === undefined){
+          records.push(record);
+        }else{
+          records[record[0]] = record[1];
+        }
+      }
+    });
+    parser.on('error', function(err){
+      callback(err, undefined, parser.api.__infoDataSet());
+    });
+    parser.on('end', function(){
+      callback(undefined, records, parser.api.__infoDataSet());
+    });
+  }
+  if(data !== undefined){
+    const writer = function(){
+      parser.write(data);
+      parser.end();
+    };
+    // Support Deno, Rollup doesnt provide a shim for setImmediate
+    if(typeof setImmediate === 'function'){
+      setImmediate(writer);
+    }else{
+      setTimeout(writer, 0);
+    }
+  }
+  return parser;
+};
+
+// export default parse
+export { parse, Parser, CsvError };

package/node_modules/csv-parse/lib/stream.js

@@ -0,0 +1,27 @@
+
+import {
+  TransformStream,
+} from 'node:stream/web';
+import {transform} from './api/index.js';
+
+const parse = (opts) => {
+  const api = transform(opts);
+  return new TransformStream({
+    async transform(chunk, controller) {
+      api.parse(chunk, false, (record) => {
+        controller.enqueue(record);
+      }, () => {
+        controller.close();
+      });
+    },
+    async flush(controller){
+      api.parse(undefined, true, (record) => {
+        controller.enqueue(record);
+      }, () => {
+        controller.close();
+      });
+    }
+  });
+};
+
+export {parse};

package/node_modules/csv-parse/lib/sync.d.ts

@@ -0,0 +1,11 @@
+
+import { Options } from './index.js';
+
+declare function parse(input: Buffer | string, options?: Options): any;
+// export default parse;
+export { parse };
+
+export {
+  CastingContext, CastingFunction, CastingDateFunction,
+  ColumnOption, Options, Info, CsvErrorCode, CsvError
+} from './index.js';

package/node_modules/csv-parse/lib/sync.js

@@ -0,0 +1,27 @@
+
+import {CsvError, transform} from './api/index.js';
+
+const parse = function(data, opts={}){
+  if(typeof data === 'string'){
+    data = Buffer.from(data);
+  }
+  const records = opts && opts.objname ? {} : [];
+  const parser = transform(opts);
+  const push = (record) => {
+    if(parser.options.objname === undefined)
+      records.push(record);
+    else{
+      records[record[0]] = record[1];
+    }
+  };
+  const close = () => {};
+  const err1 = parser.parse(data, false, push, close);
+  if(err1 !== undefined) throw err1;
+  const err2 = parser.parse(undefined, true, push, close);
+  if(err2 !== undefined) throw err2;
+  return records;
+};
+
+// export default parse
+export { parse };
+export { CsvError };

package/node_modules/csv-parse/lib/utils/ResizeableBuffer.js

@@ -0,0 +1,64 @@
+
+class ResizeableBuffer{
+  constructor(size=100){
+    this.size = size;
+    this.length = 0;
+    this.buf = Buffer.allocUnsafe(size);
+  }
+  prepend(val){
+    if(Buffer.isBuffer(val)){
+      const length = this.length + val.length;
+      if(length >= this.size){
+        this.resize();
+        if(length >= this.size){
+          throw Error('INVALID_BUFFER_STATE');
+        }
+      }
+      const buf = this.buf;
+      this.buf = Buffer.allocUnsafe(this.size);
+      val.copy(this.buf, 0);
+      buf.copy(this.buf, val.length);
+      this.length += val.length;
+    }else{
+      const length = this.length++;
+      if(length === this.size){
+        this.resize();
+      }
+      const buf = this.clone();
+      this.buf[0] = val;
+      buf.copy(this.buf,1, 0, length);
+    }
+  }
+  append(val){
+    const length = this.length++;
+    if(length === this.size){
+      this.resize();
+    }
+    this.buf[length] = val;
+  }
+  clone(){
+    return Buffer.from(this.buf.slice(0, this.length));
+  }
+  resize(){
+    const length = this.length;
+    this.size = this.size * 2;
+    const buf = Buffer.allocUnsafe(this.size);
+    this.buf.copy(buf,0, 0, length);
+    this.buf = buf;
+  }
+  toString(encoding){
+    if(encoding){
+      return this.buf.slice(0, this.length).toString(encoding);
+    }else{
+      return Uint8Array.prototype.slice.call(this.buf.slice(0, this.length));
+    }
+  }
+  toJSON(){
+    return this.toString('utf8');
+  }
+  reset(){
+    this.length = 0;
+  }
+}
+
+export default ResizeableBuffer;

package/node_modules/csv-parse/lib/utils/is_object.js

@@ -0,0 +1,6 @@
+
+const is_object = function(obj){
+  return (typeof obj === 'object' && obj !== null && !Array.isArray(obj));
+};
+
+export {is_object};

package/node_modules/csv-parse/lib/utils/underscore.js

@@ -0,0 +1,8 @@
+
+const underscore = function(str){
+  return str.replace(/([A-Z])/g, function(_, match){
+    return '_' + match.toLowerCase();
+  });
+};
+
+export {underscore};

package/node_modules/csv-parse/package.json

@@ -0,0 +1,142 @@
+{
+  "version": "5.5.5",
+  "name": "csv-parse",
+  "description": "CSV parsing implementing the Node.js `stream.Transform` API",
+  "keywords": [
+    "csv",
+    "parse",
+    "parser",
+    "convert",
+    "tsv",
+    "stream",
+    "backend",
+    "frontend"
+  ],
+  "author": "David Worms <david@adaltas.com> (https://www.adaltas.com)",
+  "contributors": [
+    "David Worms <david@adaltas.com> (https://www.adaltas.com)",
+    "Will White (https://github.com/willwhite)",
+    "Justin Latimer (https://github.com/justinlatimer)",
+    "jonseymour (https://github.com/jonseymour)",
+    "pascalopitz (https://github.com/pascalopitz)",
+    "Josh Pschorr (https://github.com/jpschorr)",
+    "Elad Ben-Israel (https://github.com/eladb)",
+    "Philippe Plantier (https://github.com/phipla)",
+    "Tim Oxley (https://github.com/timoxley)",
+    "Damon Oehlman (https://github.com/DamonOehlman)",
+    "Alexandru Topliceanu (https://github.com/topliceanu)",
+    "Visup (https://github.com/visup)",
+    "Edmund von der Burg (https://github.com/evdb)",
+    "Douglas Christopher Wilson (https://github.com/dougwilson)",
+    "Joe Eaves (https://github.com/Joeasaurus)",
+    "Mark Stosberg (https://github.com/markstos)"
+  ],
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
+      }
+    },
+    "./sync": {
+      "import": {
+        "types": "./lib/sync.d.ts",
+        "default": "./lib/sync.js"
+      },
+      "require": {
+        "types": "./dist/cjs/sync.d.cts",
+        "default": "./dist/cjs/sync.cjs"
+      }
+    },
+    "./browser/esm": {
+      "types": "./dist/esm/index.d.ts",
+      "default": "./dist/esm/index.js"
+    },
+    "./browser/esm/sync": {
+      "types": "./dist/esm/sync.d.ts",
+      "default": "./dist/esm/sync.js"
+    }
+  },
+  "devDependencies": {
+    "@rollup/plugin-eslint": "^9.0.4",
+    "@rollup/plugin-node-resolve": "^15.2.1",
+    "@types/mocha": "^10.0.1",
+    "@types/node": "^20.5.6",
+    "coffeelint": "^2.1.0",
+    "coffeescript": "^2.7.0",
+    "csv-generate": "^4.4.0",
+    "csv-spectrum": "^1.0.0",
+    "each": "^2.4.0",
+    "eslint": "^8.47.0",
+    "mocha": "^10.2.0",
+    "pad": "^3.2.0",
+    "rollup": "^3.28.1",
+    "rollup-plugin-node-builtins": "^2.1.2",
+    "rollup-plugin-node-globals": "^1.4.0",
+    "should": "^13.2.3",
+    "stream-transform": "^3.3.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.2"
+  },
+  "files": [
+    "dist",
+    "lib"
+  ],
+  "homepage": "https://csv.js.org/parse",
+  "license": "MIT",
+  "main": "./dist/cjs/index.cjs",
+  "mocha": {
+    "inline-diffs": true,
+    "loader": "./test/loaders/all.js",
+    "recursive": true,
+    "reporter": "spec",
+    "require": [
+      "should"
+    ],
+    "throw-deprecation": true,
+    "timeout": 40000
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/adaltas/node-csv.git",
+    "directory": "packages/csv-parse"
+  },
+  "scripts": {
+    "build": "npm run build:rollup && npm run build:ts",
+    "build:rollup": "npx rollup -c",
+    "build:ts": "cp lib/index.d.ts dist/cjs/index.d.cts && cp lib/sync.d.ts dist/cjs/sync.d.cts && cp lib/*.ts dist/esm",
+    "postbuild:ts": "find dist/cjs -name '*.d.cts' -exec sh -c \"sed -i \"s/\\.js'/\\.cjs'/g\" {} || sed -i '' \"s/\\.js'/\\.cjs'/g\" {}\" \\;",
+    "lint": "npm run lint:lib && npm run lint:samples && npm run lint:test",
+    "postlint": "tsc --noEmit true",
+    "lint:lib": "eslint --fix lib/*.js",
+    "lint:samples": "eslint --fix samples/*.js",
+    "lint:test": "coffeelint --fix test/*.coffee",
+    "preversion": "npm run build && git add dist",
+    "pretest": "npm run build",
+    "test": "mocha 'test/**/*.{coffee,ts}'",
+    "test:legacy": "mocha --ignore test/api.web_stream.coffee --ignore test/api.stream.finished.coffee --ignore test/api.stream.iterator.coffee --loader=./test/loaders/legacy/all.js 'test/**/*.{coffee,ts}'"
+  },
+  "type": "module",
+  "types": "dist/esm/index.d.ts",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "dist/esm/index.d.ts"
+      ],
+      "sync": [
+        "dist/esm/sync.d.ts"
+      ],
+      "browser/esm": [
+        "dist/esm/index.d.ts"
+      ],
+      "browser/esm/sync": [
+        "dist/esm/sync.d.ts"
+      ]
+    }
+  },
+  "gitHead": "410e7b172ce19e975825fcc95dbcfc0340f75af2"
+}