cucumber-reactive-reporter 1.0.11 → 1.1.1

package/dist/cucumber-reactive-reporter.cjs.js

@@ -2,181 +2,327 @@
 
 function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
 
+var module$1 = require('module');
 var fs = _interopDefault(require('fs'));
+require('fs/promises');
 var ncp = _interopDefault(require('ncp'));
 var path = _interopDefault(require('path'));
 var ut = _interopDefault(require('util'));
 
-// import { createRequire } from 'module';
-
-ncp.limit = 16;
-
-let modulePath = require.resolve("./package.json"); //trick to resolve path to the installed module
-
-/**  
- options.filter - a RegExp instance, against which each file name is tested to determine whether to copy it or not, or a function taking single parameter: copied file name, returning true or false, determining whether to copy file or not.
-
- options.transform - a function: function (read, write) { read.pipe(write) } used to apply streaming transforms while copying.
-
- options.clobber - boolean=true. if set to false, ncp will not overwrite destination files that already exist.
-
- options.dereference - boolean=false. If set to true, ncp will follow symbolic links. For example, a symlink in the source tree pointing to a regular file will become a regular file in the destination tree. Broken symlinks will result in errors.
-
- options.stopOnErr - boolean=false. If set to true, ncp will behave like cp -r, and stop on the first error it encounters. By default, ncp continues copying, logging all errors and returning an array.
-
- options.errs - stream. If options.stopOnErr is false, a stream can be provided, and errors will be written to this stream.
-*/
-
-
-let cp = (source, destination, options) => {
-  return new Promise((resolve, reject) => {
-    ncp(source, destination, err => {
-      if (err) {
-        reject(new Error(err));
-      }
-
-      resolve();
-    });
-  });
-};
-
-let _makeSafe = input => {
-  input = input.replace(/&/g, '&');
-  input = input.replace(/</g, '&lt;');
-  input = input.replace(/>/g, '&gt;');
-  return input;
-};
 /**
- * 
- * @param source path to the cucumber results json
- * @param dest folder path where html report gets written to
- * @param options 
+ * Purpose: Normalize cucumber JSON into reporter store state.
+ * Responsibilities:
+ * - Normalize legacy cucumber JSON to a stable feature/scenario/step shape.
+ * - Build feature, scenario, and step maps for the UI store.
+ * Inputs/Outputs: Accepts parsed cucumber JSON; returns store-shaped state.
+ * Invariants: Input must be legacy JSON (features/elements/steps).
+ * See: /agents.md
  */
 
-
-const generate = async (source, dest, options) => {
-  options ? true : options = {};
-  const CUCUMBER_JSON_PATH = "_cucumber-results.json";
-  const SETTINGS_JSON_PATH = "_reporter_settings.json";
-  const HTML_PATH = path.join(path.dirname(modulePath), "react"); // "linkTags": [{
-  //     "pattern": "[a-zA-Z]*-(\\d)*$",
-  //     "link": "https://bydeluxe.atlassian.net/browse/"
-  // }]
-  //defaults
-
-  const {
-    title = "Cucumber Report",
-    //report page title
-    description = "Cucumber report",
-    //description to be set at the page header
-    metadata = {},
-    linkTags = null
-  } = options;
-
-  let __dirname = path.resolve();
-
-  if (path.isAbsolute(source) === false) {
-    source = path.join(__dirname, source);
+const LEGACY_FORMAT_HELP = ["Unsupported cucumber output format.", "This reporter expects legacy JSON (features/elements/steps).", "If you are using the message formatter, rerun with --format json:<file> or", 'use inputFormat: "auto" to detect message output.'].join(" ");
+const INPUT_FORMAT_HELP = ['inputFormat must be "legacy-json" or "auto".', 'Use "legacy-json" for --format json:<file> output.', 'Use "auto" to detect and reject message formatter output explicitly.'].join(" ");
+const ATTACHMENTS_ENCODING_HELP = ['attachmentsEncoding must be "auto", "base64", or "raw".', 'Use "raw" if your cucumber JSON stores text attachments unencoded.', 'Use "base64" if text attachments are base64-encoded.', 'Use "auto" to decode base64-looking text attachments.'].join(" ");
+const normalizeMimeType = value => String(value ?? "").split(";")[0].trim().toLowerCase();
+const shouldDecodeEmbedding = mimeType => {
+  if (!mimeType) {
+    return false;
   }
-
-  fs.accessSync(source);
-
-  if (!dest) {
-    dest = path.dirname(source);
-  } else {
-    if (path.isAbsolute(dest) === false) {
-      dest = path.resolve(dest);
+  if (mimeType.startsWith("text/")) {
+    return true;
+  }
+  return mimeType === "application/json" || mimeType === "application/xml";
+};
+const looksLikeBase64 = value => {
+  if (typeof value !== "string") {
+    return false;
+  }
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.length % 4 !== 0) {
+    return false;
+  }
+  if (/[^A-Za-z0-9+/=]/.test(trimmed)) {
+    return false;
+  }
+  return true;
+};
+const isLikelyText = value => {
+  if (typeof value !== "string") {
+    return false;
+  }
+  if (value.includes("\uFFFD")) {
+    return false;
+  }
+  const sample = value.slice(0, 2000);
+  if (!sample.length) {
+    return true;
+  }
+  let printable = 0;
+  for (const char of sample) {
+    const code = char.charCodeAt(0);
+    if (code === 9 || code === 10 || code === 13) {
+      printable += 1;
+      continue;
+    }
+    if (code >= 32 && code !== 127) {
+      printable += 1;
     }
   }
-
-  console.log(`__dirname: ${__dirname}\n` + `html path: ${HTML_PATH}\n` + `source: ${source}\n` + `destination: ${dest}\n` + `title: ${title}\n` + `description: ${description}\n` + `metadata: ${ut.inspect(metadata, false, null)}\n` + `linkTags: ${ut.inspect(linkTags, false, null)}\n`); //validate input json and make a copy
-
-  let str = fs.readFileSync(source).toString();
-  let obj = JSON.parse(str);
-
-  let out = _prepDataForStore(obj);
-
-  let modifiedJSON = JSON.stringify(out);
-  let destExists = true;
-
+  return printable / sample.length > 0.85;
+};
+const decodeBase64Text = value => {
+  if (!looksLikeBase64(value)) {
+    return null;
+  }
+  const decoded = Buffer.from(value, "base64").toString("utf8");
+  if (!isLikelyText(decoded)) {
+    return null;
+  }
+  return decoded;
+};
+const formatJsonText = value => {
+  if (typeof value !== "string") {
+    return null;
+  }
   try {
-    fs.accessSync(dest);
+    const parsed = JSON.parse(value);
+    return JSON.stringify(parsed, null, 2);
   } catch (err) {
-    destExists = false;
+    return null;
   }
-
-  if (!destExists) {
-    fs.mkdirSync(dest, {
-      recursive: true
-    });
+};
+const normalizeEmbeddings = (embeddings, {
+  attachmentsEncoding
+}) => {
+  if (!Array.isArray(embeddings)) {
+    return embeddings;
   }
-
-  fs.writeFileSync(path.join(dest, CUCUMBER_JSON_PATH), modifiedJSON);
-  fs.writeFileSync(path.join(dest, SETTINGS_JSON_PATH), JSON.stringify(options));
-  await cp(HTML_PATH, dest); //swap out some tokens in the html
-
-  let indexPagePath = path.join(dest, "index.html");
-  let htmlStr = fs.readFileSync(indexPagePath, "utf8").toString();
-  let modified = htmlStr.replace(/-=title=-/g, _makeSafe(title));
-  fs.writeFileSync(indexPagePath, modified, "utf8");
-  console.log("done");
+  return embeddings.map(embedding => normalizeEmbedding(embedding, {
+    attachmentsEncoding
+  }));
 };
-
-let _prepDataForStore = data => {
-  let state = {};
-  state.features = {};
-  state.features.list = [];
-  state.features.featuresMap = {};
-  state.scenarios = {};
-  state.scenarios.list = [];
-  state.scenarios.scenariosMap = {};
-  state.steps = {};
-  state.steps.stepsMap = {};
-  state.steps.totalDurationNanoSec = 0; //parse
-
-  let featureIndex = 0;
-  console.time("loadTotal");
-
-  for (let f of data) {
-    //FEATURE
-    //cucumber id field is not guaranteed to be unique for feature/scenario/step
-    f.id = `${featureIndex++}_${f.id}`;
-
-    _processFeature(state, f); //SCENARIO
-
-
-    let numScenarios = f.elements.length; //avoid multiple lookups;
-
-    if (f.elements && numScenarios) {
-      let sc_index = 0;
-
-      for (let sc of f.elements) {
-        //need to make scenario id unique as well
-        sc_index++;
-        let sc_id_arr = sc.id.split(";");
-        sc_id_arr[0] = f.id;
-
-        if (sc_id_arr.length) {
-          sc_id_arr[1] = `${sc_index - 1}_${sc_id_arr[1]}`;
-        }
-
-        sc.id = sc_id_arr.join(";");
-
-        _processScenario(state, f.id, sc); //STEPS
-
-
-        for (let st of sc.steps) {
-          _processStep(state, sc.id, st);
-        }
+const normalizeEmbedding = (embedding, {
+  attachmentsEncoding
+}) => {
+  if (!embedding || typeof embedding !== "object") {
+    return embedding;
+  }
+  const mimeType = normalizeMimeType(embedding.mime_type ?? embedding.media?.type);
+  if (attachmentsEncoding === "raw") {
+    if (mimeType === "application/json" && typeof embedding.data === "string") {
+      const formatted = formatJsonText(embedding.data);
+      if (formatted) {
+        return {
+          ...embedding,
+          data: formatted
+        };
       }
     }
+    return embedding;
+  }
+  if (!shouldDecodeEmbedding(mimeType)) {
+    return embedding;
+  }
+  if (typeof embedding.data !== "string") {
+    return embedding;
+  }
+  // Legacy cucumber JSON embeds text payloads as base64; decode for readable output.
+  const decoded = decodeBase64Text(embedding.data);
+  if (!decoded) {
+    return embedding;
+  }
+  if (mimeType === "application/json") {
+    const formatted = formatJsonText(decoded);
+    if (!formatted) {
+      return embedding;
+    }
+    return {
+      ...embedding,
+      data: formatted
+    };
+  } else if (["application/xml", "text/xml", "text/html"].includes(mimeType)) {
+    if (!decoded.includes("<")) {
+      return embedding;
+    }
+  }
+  return {
+    ...embedding,
+    data: decoded
+  };
+};
+const resolveAttachmentsEncoding = ({
+  attachmentsEncoding,
+  cucumberVersion
+}) => {
+  if (!attachmentsEncoding) {
+    const parsed = parseCucumberMajor(cucumberVersion);
+    if (Number.isFinite(parsed)) {
+      return parsed < 7 ? "raw" : "base64";
+    }
+    return "auto";
+  }
+  if (!["auto", "base64", "raw"].includes(attachmentsEncoding)) {
+    throw new Error(ATTACHMENTS_ENCODING_HELP);
+  }
+  return attachmentsEncoding;
+};
+const parseCucumberMajor = cucumberVersion => {
+  if (!cucumberVersion) {
+    return null;
   }
+  const value = String(cucumberVersion).trim();
+  if (!value) {
+    return null;
+  }
+  const match = value.match(/(\d+)(?:\.\d+)?/);
+  if (!match) {
+    return null;
+  }
+  const major = Number.parseInt(match[1], 10);
+  return Number.isFinite(major) ? major : null;
+};
 
-  console.timeEnd("loadTotal");
+/**
+ * Convert cucumber JSON into the reporter store shape.
+ * @param {unknown} input parsed cucumber JSON
+ * @returns {Object} normalized state for the UI store
+ * @throws {Error} when input is not legacy cucumber JSON
+ * @example
+ * const state = prepareStoreState(legacyJsonArray);
+ */
+const prepareStoreState = (input, {
+  inputFormat = "legacy-json",
+  attachmentsEncoding,
+  cucumberVersion
+} = {}) => {
+  if (!["legacy-json", "auto"].includes(inputFormat)) {
+    throw new Error(INPUT_FORMAT_HELP);
+  }
+  if (inputFormat === "auto" && looksLikeMessageStream(input)) {
+    throw new Error(LEGACY_FORMAT_HELP);
+  }
+  const resolvedEncoding = resolveAttachmentsEncoding({
+    attachmentsEncoding,
+    cucumberVersion
+  });
+  const features = resolveFeatures(input);
+  if (!features) {
+    throw new Error(LEGACY_FORMAT_HELP);
+  }
+  const state = createEmptyState();
+  let featureIndex = 0;
+  for (const rawFeature of features) {
+    if (!rawFeature) {
+      continue;
+    }
+    const feature = normalizeFeature(rawFeature, featureIndex);
+    featureIndex += 1;
+    processFeature(state, feature);
+    processFeatureElements(state, feature, {
+      attachmentsEncoding: resolvedEncoding
+    });
+  }
   return state;
 };
-
-let _processFeature = (state, f) => {
+const createEmptyState = () => ({
+  features: {
+    list: [],
+    featuresMap: {}
+  },
+  scenarios: {
+    list: [],
+    scenariosMap: {}
+  },
+  steps: {
+    stepsMap: {},
+    totalDurationNanoSec: 0
+  }
+});
+const looksLikeMessageStream = input => {
+  if (!Array.isArray(input)) {
+    return false;
+  }
+  return input.some(item => {
+    if (!item || typeof item !== "object") {
+      return false;
+    }
+    return "gherkinDocument" in item || "pickle" in item || "testCaseStarted" in item || "testCaseFinished" in item || "envelope" in item;
+  });
+};
+const resolveFeatures = input => {
+  if (Array.isArray(input)) {
+    return input;
+  }
+  if (input && Array.isArray(input.features)) {
+    return input.features;
+  }
+  return null;
+};
+const normalizeFeature = (feature, index) => {
+  const baseId = feature?.id ?? feature?.name ?? "feature";
+  const elements = normalizeElements(feature);
+  return {
+    ...feature,
+    id: `${index}_${baseId}`,
+    elements,
+    tags: Array.isArray(feature?.tags) ? feature.tags : []
+  };
+};
+const normalizeElements = feature => {
+  if (!feature) {
+    return [];
+  }
+  if (Array.isArray(feature.elements)) {
+    return feature.elements;
+  }
+  if (Array.isArray(feature.scenarios)) {
+    return feature.scenarios;
+  }
+  if (Array.isArray(feature.children)) {
+    return flattenChildren(feature.children);
+  }
+  return [];
+};
+const flattenChildren = children => {
+  const flattened = [];
+  for (const child of children) {
+    if (!child) {
+      continue;
+    }
+    if (child.scenario) {
+      flattened.push(child.scenario);
+      continue;
+    }
+    if (child.background) {
+      flattened.push(child.background);
+      continue;
+    }
+    if (child.rule && Array.isArray(child.rule.children)) {
+      flattened.push(...flattenChildren(child.rule.children));
+      continue;
+    }
+    if (Array.isArray(child.children)) {
+      flattened.push(...flattenChildren(child.children));
+      continue;
+    }
+    flattened.push(child);
+  }
+  return flattened;
+};
+const normalizeScenario = (featureId, scenario, index) => {
+  const baseId = scenario?.id ?? scenario?.name ?? "scenario";
+  const scenarioId = buildScenarioId(featureId, baseId, index);
+  return {
+    ...scenario,
+    id: scenarioId,
+    tags: Array.isArray(scenario?.tags) ? scenario.tags : []
+  };
+};
+const buildScenarioId = (featureId, scenarioId, index) => {
+  const parts = String(scenarioId).split(";");
+  const suffix = parts.length > 1 ? parts[1] : parts[0];
+  return `${featureId};${index}_${suffix}`;
+};
+const processFeature = (state, feature) => {
   const {
     description,
     elements,
@@ -184,42 +330,34 @@ let _processFeature = (state, f) => {
     keyword,
     line,
     name,
-    tags: [...tags],
+    tags,
     uri
-  } = f;
-  const allTags = [...tags]; //figure out if it has failed stuff
-
+  } = feature;
+  const allTags = Array.isArray(tags) ? [...tags] : [];
   let numFailedScenarios = 0;
   let numSkippedScenarios = 0;
-
-  if (elements && elements.length) {
-    for (let el of elements) {
-      //collect scenario tags
-      if (el.tags && el.tags.length) {
-        let temp = allTags.map(t => t.name);
-        el.tags.forEach(tag => {
-          if (temp.includes(tag.name) === false) {
-            allTags.push(tag);
-          }
-        });
+  const elementList = Array.isArray(elements) ? elements : [];
+  for (const element of elementList) {
+    const elementTags = Array.isArray(element?.tags) ? element.tags : [];
+    const seen = allTags.map(tag => tag.name);
+    for (const tag of elementTags) {
+      if (tag?.name && !seen.includes(tag.name)) {
+        allTags.push(tag);
       }
-
-      if (el.steps && el.steps.length) {
-        for (let step of el.steps) {
-          if (step.result && step.result.status === "failed") {
-            numFailedScenarios++;
-            break;
-          }
-
-          if (step.result && step.result.status === "skipped") {
-            numSkippedScenarios++;
-            break;
-          }
-        }
+    }
+    const steps = Array.isArray(element?.steps) ? element.steps : [];
+    for (const step of steps) {
+      const status = step?.result?.status;
+      if (status === "failed") {
+        numFailedScenarios += 1;
+        break;
+      }
+      if (status === "skipped") {
+        numSkippedScenarios += 1;
+        break;
       }
     }
   }
-
   state.features.list.push(id);
   state.features.featuresMap[id] = {
     id,
@@ -228,20 +366,19 @@ let _processFeature = (state, f) => {
     keyword,
     name,
     line,
-    tags,
+    tags: Array.isArray(tags) ? tags : [],
     allTags,
     numFailedScenarios,
     numSkippedScenarios
   };
 };
-
-let _processScenario = (state, featureId, scenario) => {
+const processScenario = (state, featureId, scenario) => {
   const {
     id,
     keyword,
     line,
     name,
-    tags: [...tags],
+    tags,
     type,
     uri
   } = scenario;
@@ -255,13 +392,44 @@ let _processScenario = (state, featureId, scenario) => {
     name,
     passedSteps: 0,
     skippedSteps: 0,
-    tags,
+    tags: Array.isArray(tags) ? tags : [],
     type,
     uri
   };
 };
-
-let _processStep = (state, scenarioId, st) => {
+const processFeatureElements = (state, feature, {
+  attachmentsEncoding
+}) => {
+  const elements = feature.elements;
+  if (!elements.length) {
+    return;
+  }
+  let scenarioIndex = 0;
+  for (const rawScenario of elements) {
+    if (!rawScenario) {
+      continue;
+    }
+    const scenario = normalizeScenario(feature.id, rawScenario, scenarioIndex);
+    scenarioIndex += 1;
+    processScenario(state, feature.id, scenario);
+    processScenarioSteps(state, scenario, {
+      attachmentsEncoding
+    });
+  }
+};
+const processScenarioSteps = (state, scenario, {
+  attachmentsEncoding
+}) => {
+  const steps = Array.isArray(scenario.steps) ? scenario.steps : [];
+  for (const step of steps) {
+    processStep(state, scenario.id, step, {
+      attachmentsEncoding
+    });
+  }
+};
+const processStep = (state, scenarioId, step, {
+  attachmentsEncoding
+}) => {
   const {
     arguments: args,
     embeddings,
@@ -269,18 +437,22 @@ let _processStep = (state, scenarioId, st) => {
     keyword,
     line,
     name,
-    result: {
-      duration,
-      error_message,
-      status
-    }
-  } = st;
-  let location = "";
-  if (st.match) location = st.match.location;
-  let step = {
-    args,
+    result
+  } = step ?? {};
+  const {
     duration,
-    embeddings,
+    error_message,
+    status
+  } = result ?? {};
+  const durationValue = typeof duration === "string" ? Number(duration) : duration;
+  const location = step?.match?.location ?? "";
+  const normalizedEmbeddings = normalizeEmbeddings(embeddings, {
+    attachmentsEncoding
+  });
+  const stepData = {
+    args,
+    duration: durationValue,
+    embeddings: normalizedEmbeddings,
     error_message,
     keyword,
     line,
@@ -288,28 +460,177 @@ let _processStep = (state, scenarioId, st) => {
     name,
     status
   };
-  if (!state.steps.stepsMap[scenarioId]) state.steps.stepsMap[scenarioId] = {
-    steps: []
-  };
-  state.steps.stepsMap[scenarioId].steps.push(step);
-
-  if (isNaN(duration) === false) {
-    state.steps.totalDurationNanoSec = state.steps.totalDurationNanoSec + duration;
+  if (!state.steps.stepsMap[scenarioId]) {
+    state.steps.stepsMap[scenarioId] = {
+      steps: []
+    };
   }
-
-  if (!hidden || embeddings && embeddings.length) {
+  state.steps.stepsMap[scenarioId].steps.push(stepData);
+  if (Number.isFinite(durationValue)) {
+    state.steps.totalDurationNanoSec += durationValue;
+  }
+  if (!hidden || normalizedEmbeddings && normalizedEmbeddings.length) {
     if (status === "passed") {
-      state.scenarios.scenariosMap[scenarioId].passedSteps++;
+      state.scenarios.scenariosMap[scenarioId].passedSteps += 1;
     } else if (status === "skipped") {
-      state.scenarios.scenariosMap[scenarioId].skippedSteps++;
+      state.scenarios.scenariosMap[scenarioId].skippedSteps += 1;
     }
   }
-
   if (status === "failed") {
-    state.scenarios.scenariosMap[scenarioId].failedSteps++;
+    state.scenarios.scenariosMap[scenarioId].failedSteps += 1;
   }
 };
 
+/**
+ * Purpose: Generate HTML reports from cucumber JSON output.
+ * Responsibilities:
+ * - Normalize cucumber JSON into store state.
+ * - Copy report assets and write report metadata.
+ * Inputs/Outputs: Reads a cucumber JSON file and writes a report folder.
+ * Invariants: Expects legacy cucumber JSON (features/elements/steps).
+ * See: /agents.md
+ */
+const require$1 = module$1.createRequire((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('cucumber-reactive-reporter.cjs.js', document.baseURI).href)));
+ncp.limit = 16;
+const modulePath = require$1.resolve("./package.json"); //trick to resolve path to the installed module
+
+/**  
+ options.filter - a RegExp instance, against which each file name is tested to determine whether to copy it or not, or a function taking single parameter: copied file name, returning true or false, determining whether to copy file or not.
+
+ options.transform - a function: function (read, write) { read.pipe(write) } used to apply streaming transforms while copying.
+
+ options.clobber - boolean=true. if set to false, ncp will not overwrite destination files that already exist.
+
+ options.dereference - boolean=false. If set to true, ncp will follow symbolic links. For example, a symlink in the source tree pointing to a regular file will become a regular file in the destination tree. Broken symlinks will result in errors.
+
+ options.stopOnErr - boolean=false. If set to true, ncp will behave like cp -r, and stop on the first error it encounters. By default, ncp continues copying, logging all errors and returning an array.
+
+ options.errs - stream. If options.stopOnErr is false, a stream can be provided, and errors will be written to this stream.
+*/
+
+let cp = (source, destination, options) => {
+  return new Promise((resolve, reject) => {
+    ncp(source, destination, err => {
+      if (err) {
+        reject(new Error(err));
+      }
+      resolve();
+    });
+  });
+};
+const _makeSafe = input => {
+  input = input.replace(/&/g, '&amp;');
+  input = input.replace(/</g, '&lt;');
+  input = input.replace(/>/g, '&gt;');
+  return input;
+};
+
+/**
+ * Generate a report from cucumber JSON output.
+ * @param {string} source path to the cucumber results JSON file
+ * @param {string} dest folder path where the HTML report gets written
+ * @param {Object} options report configuration overrides
+ * @param {"legacy-json"|"auto"} [options.inputFormat] input JSON format selector
+ * @param {"auto"|"base64"|"raw"} [options.attachmentsEncoding] attachment encoding
+ * @param {string} [options.cucumberVersion] cucumber version (for encoding hints)
+ * @returns {Promise<void>} resolves when report assets are written
+ * @throws {Error} when input JSON is invalid or unsupported
+ * @example
+ * await generate("results/cucumber.json", "reports/out", { title: "Run #1" });
+ */
+const generate = async (source, dest, options) => {
+  options ? true : options = {};
+  const CUCUMBER_JSON_PATH = "_cucumber-results.json";
+  const SETTINGS_JSON_PATH = "_reporter_settings.json";
+  const HTML_PATH = path.join(path.dirname(modulePath), "react");
+
+  // "linkTags": [{
+  //     "pattern": "[a-zA-Z]*-(\\d)*$",
+  //     "link": "https://bydeluxe.atlassian.net/browse/"
+
+  // }]
+  //defaults
+  const {
+    title = "Cucumber Report",
+    //report page title
+    description = "Cucumber report",
+    //description to be set at the page header
+    metadata = {},
+    linkTags = null,
+    inputFormat = "legacy-json",
+    attachmentsEncoding,
+    cucumberVersion
+  } = options;
+  let __dirname = path.resolve();
+  if (path.isAbsolute(source) === false) {
+    source = path.join(__dirname, source);
+  }
+  fs.accessSync(source);
+  if (!dest) {
+    dest = path.dirname(source);
+  } else {
+    if (path.isAbsolute(dest) === false) {
+      dest = path.resolve(dest);
+    }
+  }
+  console.log(`__dirname: ${__dirname}\n` + `html path: ${HTML_PATH}\n` + `source: ${source}\n` + `destination: ${dest}\n` + `title: ${title}\n` + `description: ${description}\n` + `metadata: ${ut.inspect(metadata, false, null)}\n` + `linkTags: ${ut.inspect(linkTags, false, null)}\n`);
+
+  //validate input json and make a copy
+  let str = fs.readFileSync(source, "utf8");
+  let obj = parseInputData(source, str);
+  let out = prepareStoreState(obj, {
+    inputFormat,
+    attachmentsEncoding,
+    cucumberVersion
+  });
+  let modifiedJSON = JSON.stringify(out);
+  let destExists = true;
+  try {
+    fs.accessSync(dest);
+  } catch (err) {
+    destExists = false;
+  }
+  if (!destExists) {
+    fs.mkdirSync(dest, {
+      recursive: true
+    });
+  }
+  fs.writeFileSync(path.join(dest, CUCUMBER_JSON_PATH), modifiedJSON);
+  fs.writeFileSync(path.join(dest, SETTINGS_JSON_PATH), JSON.stringify(options));
+  await cp(HTML_PATH, dest);
+  //swap out some tokens in the html
+  let indexPagePath = path.join(dest, "index.html");
+  let htmlStr = fs.readFileSync(indexPagePath, "utf8").toString();
+  let modified = htmlStr.replace(/-=title=-/g, _makeSafe(title));
+  fs.writeFileSync(indexPagePath, modified, "utf8");
+  console.log("done");
+};
+const parseInputData = (source, rawText) => {
+  try {
+    return JSON.parse(rawText);
+  } catch (err) {
+    const ndjson = parseNdjson(rawText);
+    if (ndjson) {
+      return ndjson;
+    }
+    throw new Error(`Invalid JSON in ${source}: ${err.message}`);
+  }
+};
+const parseNdjson = rawText => {
+  const lines = rawText.split(/\r?\n/).filter(line => line.trim().length);
+  if (!lines.length) {
+    return null;
+  }
+  const items = [];
+  for (const line of lines) {
+    try {
+      items.push(JSON.parse(line));
+    } catch (err) {
+      return null;
+    }
+  }
+  return items;
+};
 var index = {
   generate: generate
 };