Refactor code-style

Author: wooorm

lib/automatic-runtime-html.js

@@ -4,4 +4,4 @@ import {h} from './index.js'
 // Export `JSX` as a global for TypeScript.
 export * from './jsx-automatic.js'
 
-export const {Fragment, jsx, jsxDEV, jsxs} = createAutomaticRuntime(h)
+export const {Fragment, jsxDEV, jsxs, jsx} = createAutomaticRuntime(h)

lib/automatic-runtime-svg.js

@@ -4,4 +4,4 @@ import {s} from './index.js'
 // Export `JSX` as a global for TypeScript.
 export * from './jsx-automatic.js'
 
-export const {Fragment, jsx, jsxDEV, jsxs} = createAutomaticRuntime(s)
+export const {Fragment, jsxDEV, jsxs, jsx} = createAutomaticRuntime(s)

lib/create-automatic-runtime.js

@@ -28,13 +28,13 @@ export function createAutomaticRuntime(f) {
    * @overload
    * @param {null} type
    * @param {{children?: Child}} properties
-   * @param {string} [key]
+   * @param {string | null | undefined} [key]
    * @returns {Root}
    *
    * @overload
    * @param {string} type
    * @param {JSXProps} properties
-   * @param {string} [key]
+   * @param {string | null | undefined} [key]
    * @returns {Element}
    *
    * @param {string | null} type
@@ -53,5 +53,5 @@ export function createAutomaticRuntime(f) {
     return result
   }
 
-  return {Fragment: null, jsx, jsxDEV: jsx, jsxs: jsx}
+  return {Fragment: null, jsxDEV: jsx, jsxs: jsx, jsx}
 }

lib/create-h.js

@@ -1,59 +1,85 @@
 /**
  * @typedef {import('hast').Element} Element
  * @typedef {import('hast').Nodes} Nodes
- * @typedef {import('hast').Root} Root
  * @typedef {import('hast').RootContent} RootContent
+ * @typedef {import('hast').Root} Root
  *
  * @typedef {import('property-information').Info} Info
  * @typedef {import('property-information').Schema} Schema
  */
 
+/**
+ * @typedef {Array<Nodes | PrimitiveChild>} ArrayChildNested
+ *   List of children (deep).
+ */
+
+/**
+ * @typedef {Array<ArrayChildNested | Nodes | PrimitiveChild>} ArrayChild
+ *   List of children.
+ */
+
+/**
+ * @typedef {Array<number | string>} ArrayValue
+ *   List of property values for space- or comma separated values (such as `className`).
+ */
+
+/**
+ * @typedef {ArrayChild | Nodes | PrimitiveChild} Child
+ *   Acceptable child value.
+ */
+
+/**
+ * @typedef {number | string | null | undefined} PrimitiveChild
+ *   Primitive children, either ignored (nullish), or turned into text nodes.
+ */
+
+/**
+ * @typedef {boolean | number | string | null | undefined} PrimitiveValue
+ *   Primitive property value.
+ */
+
+/**
+ * @typedef {Record<string, PropertyValue | Style>} Properties
+ *   Acceptable value for element properties.
+ */
+
+/**
+ * @typedef {ArrayValue | PrimitiveValue} PropertyValue
+ *   Primitive value or list value.
+ */
+
 /**
  * @typedef {Element | Root} Result
  *   Result from a `h` (or `s`) call.
- *
+ */
+
+/**
  * @typedef {number | string} StyleValue
  *   Value for a CSS style field.
+ */
+
+/**
  * @typedef {Record<string, StyleValue>} Style
  *   Supported value of a `style` prop.
- * @typedef {boolean | number | string | null | undefined} PrimitiveValue
- *   Primitive property value.
- * @typedef {Array<number | string>} ArrayValue
- *   List of property values for space- or comma separated values (such as `className`).
- * @typedef {ArrayValue | PrimitiveValue} PropertyValue
- *   Primitive value or list value.
- * @typedef {{[property: string]: PropertyValue | Style}} Properties
- *   Acceptable value for element properties.
- *
- * @typedef {number | string | null | undefined} PrimitiveChild
- *   Primitive children, either ignored (nullish), or turned into text nodes.
- * @typedef {Array<ArrayChildNested | Nodes | PrimitiveChild>} ArrayChild
- *   List of children.
- * @typedef {Array<Nodes | PrimitiveChild>} ArrayChildNested
- *   List of children (deep).
- * @typedef {ArrayChild | Nodes | PrimitiveChild} Child
- *   Acceptable child value.
  */
 
-import {parse as commas} from 'comma-separated-tokens'
+import {parse as parseCommas} from 'comma-separated-tokens'
 import {parseSelector} from 'hast-util-parse-selector'
 import {find, normalize} from 'property-information'
-import {parse as spaces} from 'space-separated-tokens'
-
-const own = {}.hasOwnProperty
+import {parse as parseSpaces} from 'space-separated-tokens'
 
 /**
  * @param {Schema} schema
  *   Schema to use.
  * @param {string} defaultTagName
  *   Default tag name.
- * @param {Array<string> | undefined} [caseSensitive]
+ * @param {ReadonlyArray<string> | undefined} [caseSensitive]
  *   Case-sensitive tag names (default: `undefined`).
  * @returns
  *   `h`.
  */
 export function createH(schema, defaultTagName, caseSensitive) {
-  const adjust = caseSensitive && createAdjustMap(caseSensitive)
+  const adjust = caseSensitive ? createAdjustMap(caseSensitive) : undefined
 
   /**
    * Hyperscript compatible DSL for creating virtual hast trees.
@@ -84,41 +110,34 @@ export function createH(schema, defaultTagName, caseSensitive) {
    *   Result.
    */
   function h(selector, properties, ...children) {
-    let index = -1
     /** @type {Result} */
     let node
 
-    if (selector === undefined || selector === null) {
+    if (selector === null || selector === undefined) {
       node = {type: 'root', children: []}
       // Properties are not supported for roots.
       const child = /** @type {Child} */ (properties)
       children.unshift(child)
     } else {
       node = parseSelector(selector, defaultTagName)
       // Normalize the name.
-      node.tagName = node.tagName.toLowerCase()
-      if (adjust && own.call(adjust, node.tagName)) {
-        node.tagName = adjust[node.tagName]
-      }
+      const lower = node.tagName.toLowerCase()
+      const adjusted = adjust ? adjust.get(lower) : undefined
+      node.tagName = adjusted || lower
 
       // Handle properties.
       if (isChild(properties)) {
         children.unshift(properties)
       } else {
-        /** @type {string} */
-        let key
-
-        for (key in properties) {
-          if (own.call(properties, key)) {
-            addProperty(schema, node.properties, key, properties[key])
-          }
+        for (const [key, value] of Object.entries(properties)) {
+          addProperty(schema, node.properties, key, value)
         }
       }
     }
 
     // Handle children.
-    while (++index < children.length) {
-      addChild(node.children, children[index])
+    for (const child of children) {
+      addChild(node.children, child)
     }
 
     if (node.type === 'element' && node.tagName === 'template') {
@@ -160,7 +179,7 @@ function isChild(value) {
     if (value && typeof value === 'object') {
       if (!Array.isArray(value)) return true
 
-      const list = /** @type {Array<unknown>} */ (value)
+      const list = /** @type {ReadonlyArray<unknown>} */ (value)
 
       for (const item of list) {
         if (typeof item !== 'number' && typeof item !== 'string') {
@@ -195,12 +214,11 @@ function isChild(value) {
  */
 function addProperty(schema, properties, key, value) {
   const info = find(schema, key)
-  let index = -1
   /** @type {PropertyValue} */
   let result
 
   // Ignore nullish and NaN values.
-  if (value === undefined || value === null) return
+  if (value === null || value === undefined) return
 
   if (typeof value === 'number') {
     // Ignore NaN.
@@ -215,16 +233,16 @@ function addProperty(schema, properties, key, value) {
   // Handle list values.
   else if (typeof value === 'string') {
     if (info.spaceSeparated) {
-      result = spaces(value)
+      result = parseSpaces(value)
     } else if (info.commaSeparated) {
-      result = commas(value)
+      result = parseCommas(value)
     } else if (info.commaOrSpaceSeparated) {
-      result = spaces(commas(value).join(' '))
+      result = parseSpaces(parseCommas(value).join(' '))
     } else {
       result = parsePrimitive(info, info.property, value)
     }
   } else if (Array.isArray(value)) {
-    result = value.concat()
+    result = [...value]
   } else {
     result = info.property === 'style' ? style(value) : String(value)
   }
@@ -233,12 +251,13 @@ function addProperty(schema, properties, key, value) {
     /** @type {Array<number | string>} */
     const finalResult = []
 
-    while (++index < result.length) {
+    for (const item of result) {
       // Assume no booleans in array.
-      const value = /** @type {number | string} */ (
-        parsePrimitive(info, info.property, result[index])
+      finalResult.push(
+        /** @type {number | string} */ (
+          parsePrimitive(info, info.property, item)
+        )
       )
-      finalResult[index] = value
     }
 
     result = finalResult
@@ -247,8 +266,9 @@ function addProperty(schema, properties, key, value) {
   // Class names (which can be added both on the `selector` and here).
   if (info.property === 'className' && Array.isArray(properties.className)) {
     // Assume no booleans in `className`.
-    const value = /** @type {number | string} */ (result)
-    result = properties.className.concat(value)
+    result = properties.className.concat(
+      /** @type {Array<number | string> | number | string} */ (result)
+    )
   }
 
   properties[info.property] = result
@@ -263,15 +283,13 @@ function addProperty(schema, properties, key, value) {
  *   Nothing.
  */
 function addChild(nodes, value) {
-  let index = -1
-
-  if (value === undefined || value === null) {
+  if (value === null || value === undefined) {
     // Empty.
-  } else if (typeof value === 'string' || typeof value === 'number') {
+  } else if (typeof value === 'number' || typeof value === 'string') {
     nodes.push({type: 'text', value: String(value)})
   } else if (Array.isArray(value)) {
-    while (++index < value.length) {
-      addChild(nodes, value[index])
+    for (const child of value) {
+      addChild(nodes, child)
     }
   } else if (typeof value === 'object' && 'type' in value) {
     if (value.type === 'root') {
@@ -316,21 +334,17 @@ function parsePrimitive(info, name, value) {
 /**
  * Serialize a `style` object as a string.
  *
- * @param {Style} value
+ * @param {Style} styles
  *   Style object.
  * @returns {string}
  *   CSS string.
  */
-function style(value) {
+function style(styles) {
   /** @type {Array<string>} */
   const result = []
-  /** @type {string} */
-  let key
 
-  for (key in value) {
-    if (own.call(value, key)) {
-      result.push([key, value[key]].join(': '))
-    }
+  for (const [key, value] of Object.entries(styles)) {
+    result.push([key, value].join(': '))
   }
 
   return result.join('; ')
@@ -339,18 +353,17 @@ function style(value) {
 /**
  * Create a map to adjust casing.
  *
- * @param {Array<string>} values
+ * @param {ReadonlyArray<string>} values
  *   List of properly cased keys.
- * @returns {Record<string, string>}
+ * @returns {Map<string, string>}
  *   Map of lowercase keys to uppercase keys.
  */
 function createAdjustMap(values) {
-  /** @type {Record<string, string>} */
-  const result = {}
-  let index = -1
+  /** @type {Map<string, string>} */
+  const result = new Map()
 
-  while (++index < values.length) {
-    result[values[index].toLowerCase()] = values[index]
+  for (const value of values) {
+    result.set(value.toLowerCase(), value)
   }
 
   return result

lib/index.js

@@ -1,8 +1,14 @@
 /**
  * @typedef {import('./create-h.js').Child} Child
  *   Acceptable child value.
+ */
+
+/**
  * @typedef {import('./create-h.js').Properties} Properties
  *   Acceptable value for element properties.
+ */
+
+/**
  * @typedef {import('./create-h.js').Result} Result
  *   Result from a `h` (or `s`) call.
  */

lib/svg-case-sensitive-tag-names.js

@@ -1,3 +1,8 @@
+/**
+ * List of case-sensitive SVG tag names.
+ *
+ * @type {ReadonlyArray<string>}
+ */
 export const svgCaseSensitiveTagNames = [
   'altGlyph',
   'altGlyphDef',

package.json

@@ -27,7 +27,6 @@
     "tsd": "^0.31.0",
     "type-coverage": "^2.0.0",
     "typescript": "~5.4.0",
-    "unist-builder": "^4.0.0",
     "xo": "^0.60.0"
   },
   "exports": {