Add strict to tsconfig.json

Author: wooorm

lib/index.js

@@ -22,9 +22,9 @@
  * @property {boolean} [allowComments] Whether to allow comments
  * @property {boolean} [allowDoctypes] Whether to allow doctypes
  *
- * @typedef {(schema: Schema, value: unknown, node: Node, stack: Array.<string>) => unknown} Handler
+ * @typedef {(schema: Schema, value: any, node: any, stack: Array.<string>) => unknown} Handler
  * @typedef {Object.<string, Handler>} NodeDefinition
- * @typedef {((schema: Schema, node: Node) => NodeDefinition)} NodeDefinitionGetter
+ * @typedef {((schema: Schema, node: Node) => NodeDefinition|undefined)} NodeDefinitionGetter
  * @typedef {Object.<string, NodeDefinition|NodeDefinitionGetter>} NodeSchema
  */
 
@@ -68,7 +68,7 @@ export function sanitize(node, schema) {
         if (replace.length === 1) {
           ctx = replace[0]
         } else {
-          // @ts-ignore Assume `root` is not a child.
+          // @ts-expect-error Assume `root` is not a child.
           ctx.children = replace
         }
       } else {
@@ -86,17 +86,18 @@ export function sanitize(node, schema) {
  * @param {Schema} schema
  * @param {Node} node
  * @param {Array.<string>} stack
- * @returns {Node|Array.<Node>|null}
+ * @returns {Node|Array.<Node>|undefined}
  */
 function one(schema, node, stack) {
   const type = node && node.type
   /** @type {Node} */
-  // @ts-ignore rest of props added later.
+  // @ts-expect-error rest of props added later.
   const replacement = {type: node.type}
-  /** @type {boolean} */
+  /** @type {boolean|undefined} */
   let replace
 
   if (own.call(nodeSchema, type)) {
+    /** @type {NodeDefinition|NodeDefinitionGetter|undefined} */
     let definition = nodeSchema[type]
 
     if (typeof definition === 'function') {
@@ -112,14 +113,20 @@ function one(schema, node, stack) {
 
       for (key in allowed) {
         if (own.call(allowed, key)) {
+          // @ts-expect-error: fine.
+          // type-coverage:ignore-next-line
           const result = allowed[key](schema, node[key], node, stack)
 
           // eslint-disable-next-line max-depth
           if (result === false) {
-            replace = null
+            replace = undefined
             // Set the non-safe value.
+            // @ts-expect-error: fine.
+            // type-coverage:ignore-next-line
             replacement[key] = node[key]
           } else if (result !== undefined && result !== null) {
+            // @ts-expect-error: fine.
+            // type-coverage:ignore-next-line
             replacement[key] = result
           }
         }
@@ -132,16 +139,18 @@ function one(schema, node, stack) {
   }
 
   return replacement.type === 'element' &&
+    schema.strip &&
     !schema.strip.includes(replacement.tagName)
     ? replacement.children
-    : null
+    : undefined
 }
 
 /**
  * Sanitize `children`.
  *
  * @type {Handler}
  * @param {Array.<Node>} children
+ * @param {Node} node
  * @returns {Array.<Node>}
  */
 function all(schema, children, node, stack) {
@@ -177,12 +186,12 @@ function all(schema, children, node, stack) {
 
 /** @type {NodeDefinitionGetter} */
 function handleDoctype(schema) {
-  return schema.allowDoctypes ? {name: handleDoctypeName} : null
+  return schema.allowDoctypes ? {name: handleDoctypeName} : undefined
 }
 
 /** @type {NodeDefinitionGetter} */
 function handleComment(schema) {
-  return schema.allowComments ? {value: handleCommentValue} : null
+  return schema.allowComments ? {value: handleCommentValue} : undefined
 }
 
 /**
@@ -196,14 +205,14 @@ function handleComment(schema) {
 function handleProperties(schema, properties, node, stack) {
   const name = handleTagName(schema, node.tagName, node, stack)
   /* c8 ignore next */
+  const attrs = schema.attributes || {}
+  /* c8 ignore next */
   const reqs = schema.required || {}
   const props = properties || {}
   const allowed = Object.assign(
     {},
-    toPropertyValueMap(schema.attributes['*']),
-    toPropertyValueMap(
-      name && own.call(schema.attributes, name) ? schema.attributes[name] : []
-    )
+    toPropertyValueMap(attrs['*']),
+    toPropertyValueMap(name && own.call(attrs, name) ? attrs[name] : [])
   )
   /** @type {Properties} */
   const result = {}
@@ -259,19 +268,25 @@ function handleDoctypeName() {
  * Sanitize `tagName`.
  *
  * @type {Handler}
+ * @param {unknown} tagName
+ * @param {Node} _
  * @returns {string|false}
  */
 function handleTagName(schema, tagName, _, stack) {
   const name = typeof tagName === 'string' ? tagName : ''
   let index = -1
 
-  if (!name || name === '*' || !schema.tagNames.includes(name)) {
+  if (
+    !name ||
+    name === '*' ||
+    (schema.tagNames && !schema.tagNames.includes(name))
+  ) {
     return false
   }
 
   // Some nodes can break out of their context if they don’t have a certain
   // ancestor.
-  if (own.call(schema.ancestors, name)) {
+  if (schema.ancestors && own.call(schema.ancestors, name)) {
     while (++index < schema.ancestors[name].length) {
       if (stack.includes(schema.ancestors[name][index])) {
         return name
@@ -288,6 +303,7 @@ function handleTagName(schema, tagName, _, stack) {
  * See <https://html.spec.whatwg.org/multipage/parsing.html#serialising-html-fragments>
  *
  * @type {Handler}
+ * @param {unknown} value
  * @returns {string}
  */
 function handleCommentValue(_, value) {
@@ -301,6 +317,7 @@ function handleCommentValue(_, value) {
  * Sanitize `value`.
  *
  * @type {Handler}
+ * @param {unknown} value
  * @returns {string}
  */
 function handleValue(_, value) {
@@ -311,6 +328,7 @@ function handleValue(_, value) {
  * Allow `value`.
  *
  * @type {Handler}
+ * @param {unknown} value
  */
 function allow(_, value) {
   return value
@@ -334,7 +352,7 @@ function handlePropertyValues(schema, values, prop, definition) {
     const value = handlePropertyValue(schema, values[index], prop, definition)
 
     if (value !== undefined && value !== null) {
-      // @ts-ignore Assume no booleans were in arrays.
+      // @ts-expect-error Assume no booleans were in arrays.
       result.push(value)
     }
   }
@@ -359,7 +377,11 @@ function handlePropertyValue(schema, value, prop, definition) {
     safeProtocol(schema, value, prop) &&
     (definition.length === 0 || definition.includes(value))
   ) {
-    return schema.clobber.includes(prop) ? schema.clobberPrefix + value : value
+    return schema.clobberPrefix &&
+      schema.clobber &&
+      schema.clobber.includes(prop)
+      ? schema.clobberPrefix + value
+      : value
   }
 }
 
@@ -377,9 +399,10 @@ function safeProtocol(schema, value, prop) {
   const questionMark = url.indexOf('?')
   const numberSign = url.indexOf('#')
   const slash = url.indexOf('/')
-  const protocols = own.call(schema.protocols, prop)
-    ? schema.protocols[prop].concat()
-    : []
+  const protocols =
+    schema.protocols && own.call(schema.protocols, prop)
+      ? schema.protocols[prop].concat()
+      : []
   let index = -1
 
   if (

package.json

@@ -81,6 +81,11 @@
   "typeCoverage": {
     "atLeast": 100,
     "detail": true,
-    "strict": true
+    "strict": true,
+    "ignoreCatch": true,
+    "#": "Couple of needed `any`s",
+    "ignoreFiles": [
+      "lib/index.d.ts"
+    ]
   }
 }

test.js

@@ -11,20 +11,21 @@ const own = {}.hasOwnProperty
 
 test('sanitize()', (t) => {
   t.test('non-node', (t) => {
-    // @ts-ignore runtime.
+    // @ts-expect-error runtime.
     t.equal(html(sanitize(true)), '', 'should ignore non-nodes (#1)')
+    // @ts-expect-error runtime.
     t.equal(html(sanitize(null)), '', 'should ignore non-nodes (#2)')
-    // @ts-ignore runtime.
+    // @ts-expect-error runtime.
     t.equal(html(sanitize(1)), '', 'should ignore non-nodes (#3)')
-    // @ts-ignore runtime.
+    // @ts-expect-error runtime.
     t.equal(html(sanitize([])), '', 'should ignore non-nodes (#4)')
 
     t.end()
   })
 
   t.test('unknown nodes', (t) => {
     t.equal(
-      // @ts-ignore runtime.
+      // @ts-expect-error runtime.
       html(sanitize(u('unknown', '<xml></xml>'))),
       '',
       'should ignore unknown nodes'
@@ -34,25 +35,25 @@ test('sanitize()', (t) => {
   })
 
   t.test('ignored nodes', (t) => {
-    // @ts-ignore runtime.
+    // @ts-expect-error runtime.
     t.equal(html(sanitize(u('raw', '<xml></xml>'))), '', 'should ignore `raw`')
 
     t.equal(
-      // @ts-ignore runtime.
+      // @ts-expect-error runtime.
       html(sanitize(u('directive', {name: '!alpha'}, '!alpha bravo'))),
       '',
       'should ignore declaration `directive`s'
     )
 
     t.equal(
-      // @ts-ignore runtime.
+      // @ts-expect-error runtime.
       html(sanitize(u('directive', {name: '?xml'}, '?xml version="1.0"'))),
       '',
       'should ignore processing instruction `directive`s'
     )
 
     t.equal(
-      // @ts-ignore runtime.
+      // @ts-expect-error runtime.
       html(sanitize(u('characterData', 'alpha'))),
       '',
       'should ignore `characterData`s'
@@ -75,7 +76,7 @@ test('sanitize()', (t) => {
     )
 
     t.equal(
-      // @ts-ignore runtime.
+      // @ts-expect-error runtime.
       html(sanitize(u('comment', {toString}), {allowComments: true})),
       '<!---->',
       'should ignore non-string `value`s with `allowComments: true`'
@@ -147,7 +148,7 @@ test('sanitize()', (t) => {
     )
 
     t.equal(
-      // @ts-ignore runtime.
+      // @ts-expect-error runtime.
       html(sanitize(u('text', {toString}))),
       '',
       'should ignore non-string `value`s'
@@ -205,7 +206,7 @@ test('sanitize()', (t) => {
     )
 
     t.deepEqual(
-      // @ts-ignore runtime.
+      // @ts-expect-error runtime.
       sanitize({
         type: 'element',
         properties: {},
@@ -216,7 +217,7 @@ test('sanitize()', (t) => {
     )
 
     t.deepEqual(
-      // @ts-ignore runtime.
+      // @ts-expect-error runtime.
       sanitize({type: 'element', tagName: 'div'}),
       h(''),
       'should support elements without children / properties'
@@ -310,14 +311,14 @@ test('sanitize()', (t) => {
     )
 
     t.deepEqual(
-      // @ts-ignore runtime.
+      // @ts-expect-error runtime.
       sanitize(u('element', {tagName: 'img', properties: {alt: null}})),
       h('img'),
       'should ignore `null`'
     )
 
     t.deepEqual(
-      // @ts-ignore runtime.
+      // @ts-expect-error runtime.
       sanitize(u('element', {tagName: 'img', properties: {alt: undefined}})),
       h('img'),
       'should ignore `undefined`'
@@ -336,21 +337,21 @@ test('sanitize()', (t) => {
     )
 
     t.deepEqual(
-      // @ts-ignore runtime.
+      // @ts-expect-error runtime.
       sanitize(u('element', {tagName: 'img', properties: {alt: {toString}}})),
       h('img'),
       'should ignore objects'
     )
 
     t.deepEqual(
       sanitize(
-        // @ts-ignore runtime.
+        // @ts-expect-error runtime.
         u('element', {
           tagName: 'img',
           properties: {alt: [1, true, 'three', [4], {toString}]}
         })
       ),
-      // @ts-ignore runtime.
+      // @ts-expect-error runtime.
       h('img', {alt: [1, true, 'three']}),
       'should supports arrays'
     )

tsconfig.json

@@ -10,6 +10,7 @@
     "declaration": true,
     "emitDeclarationOnly": true,
     "allowSyntheticDefaultImports": true,
-    "skipLibCheck": true
+    "skipLibCheck": true,
+    "strict": true
   }
 }