refactor: pluggable optional deps funcs centralized

.mocharc.js

@@ -26,8 +26,7 @@ Copyright (c) OWASP Foundation. All Rights Reserved.
 module.exports = {
   timeout: 10000,
   spec: [
-    'tests',
-    'libs'
+    'tests'
   ],
   recursive: true,
   parallel: false, // if true, then some IDEs cannot run it

src/_optPlug.node/_wrapper.ts

@@ -0,0 +1,53 @@
+/*!
+This file is part of CycloneDX JavaScript Library.
+
+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.
+
+SPDX-License-Identifier: Apache-2.0
+Copyright (c) OWASP Foundation. All Rights Reserved.
+*/
+
+import { OptPlugError } from './errors'
+
+type WillThrow = (() => never) & { fails: true }
+type WillNotFailRightAway<T> = Omit<T, 'fails'>
+type PossibleFunctionalities<Functionality> = Array<[string, () => Functionality | undefined]>
+
+function makeWIllThrow (message: string): WillThrow {
+  const f: WillThrow = function (): never {
+    throw new OptPlugError(message)
+  }
+  f.fails = true
+  return Object.freeze(f)
+}
+
+export default function <Functionality extends WillNotFailRightAway<Functionality>> (
+  name: string,
+  pf: PossibleFunctionalities<Functionality>
+): Functionality | WillThrow {
+  for (const [, getF] of pf) {
+    try {
+      const f = getF()
+      if (f !== undefined) {
+        return f
+      }
+    } catch {
+      /* pass */
+    }
+  }
+  return makeWIllThrow(
+    `No ${name} available.` +
+    ' Please install any of the optional dependencies: ' +
+    pf.map(kv => kv[0]).join(' || ')
+  )
+}

libs/universal-node-xml/stringify.d.ts → src/_optPlug.node/errors.ts

@@ -17,15 +17,11 @@ SPDX-License-Identifier: Apache-2.0
 Copyright (c) OWASP Foundation. All Rights Reserved.
 */
 
-import type { SerializerOptions } from '../../src/serialize/types'
-import type { SimpleXml } from '../../src/serialize/xml/types'
+export class OptPlugError extends Error {
+  readonly cause: any | undefined
 
-declare interface ThrowError {
-  /** @throws {@link Error} */
-  (..._: any[]): never
-  fails: true
+  constructor (message: string, cause?: any) {
+    super(message)
+    this.cause = cause
+  }
 }
-
-declare type Stringify = (element: SimpleXml.Element, options?: SerializerOptions) => string
-declare const stringify: Stringify | ThrowError
-export = stringify

libs/universal-node-xml/__stringifiers/xmlbuilder2.js → src/_optPlug.node/xmlStringify/__opts/xmlbuilder2.ts

@@ -17,32 +17,22 @@ SPDX-License-Identifier: Apache-2.0
 Copyright (c) OWASP Foundation. All Rights Reserved.
 */
 
-const { create } = require('xmlbuilder2')
-const { getNS, makeIndent } = require('./_helpers')
+import { create } from 'xmlbuilder2'
+import type { XMLBuilder } from 'xmlbuilder2/lib/interfaces'
 
-module.exports = typeof create === 'function'
-  ? stringify
-  /* c8 ignore next */
-  : undefined
+import type { SerializerOptions } from '../../../serialize/types'
+import type { SimpleXml } from '../../../serialize/xml/types'
+import type { Functionality } from '../'
 
-/* eslint-disable jsdoc/valid-types */
-
-/**
- * @typedef {import('xmlbuilder2/lib/interfaces').XMLBuilder} XMLBuilder
- */
-
-/**
- * @typedef {import('../../../src/serialize/xml/types').SimpleXml.Element} Element
- */
-
-/* eslint-enable jsdoc/valid-types */
+if (typeof create !== 'function') {
+  throw new Error('`create` is not a function')
+}
 
-/**
- * @param {Element} rootElement
- * @param {string|number|undefined} [space]
- * @return {string}
- */
-function stringify (rootElement, { space } = {}) {
+/** @internal */
+export default (function (
+  rootElement: SimpleXml.Element,
+  { space }: SerializerOptions = {}
+): string {
   const indent = makeIndent(space)
   const doc = create({ encoding: 'UTF-8' })
   addEle(doc, rootElement)
@@ -52,15 +42,16 @@ function stringify (rootElement, { space } = {}) {
     prettyPrint: indent.length > 0,
     indent
   })
-}
+}) satisfies Functionality
 
-/**
- * @param {XMLBuilder} parent
- * @param {Element} element
- * @param {?string} [parentNS]
- */
-function addEle (parent, element, parentNS = null) {
-  if (element.type !== 'element') { return }
+function addEle (
+  parent: XMLBuilder,
+  element: SimpleXml.Element | SimpleXml.Comment,
+  parentNS: string | null = null
+): void {
+  if (element.type !== 'element') {
+    return
+  }
   const ns = getNS(element) ?? parentNS
   const ele = parent.ele(ns, element.name, element.attributes)
   if (element.children === undefined) {
@@ -73,3 +64,20 @@ function addEle (parent, element, parentNS = null) {
     }
   }
 }
+
+function getNS (element: SimpleXml.Element): string | null {
+  const ns = (element.namespace ?? element.attributes?.xmlns)?.toString() ?? ''
+  return ns.length > 0
+    ? ns
+    : null
+}
+
+function makeIndent (space: string | number | any): string {
+  if (typeof space === 'number') {
+    return ' '.repeat(Math.max(0, space))
+  }
+  if (typeof space === 'string') {
+    return space
+  }
+  return ''
+}