jsxpression 0.2.4 → 0.3.0

package/src/codegen/schema/utils.ts

@@ -18,10 +18,12 @@ export function mapSchemaTypeToTypeScript(prop: PropertySchema, depth: number =
       }
       return "boolean";
     case "array": {
+      // oxlint-disable-next-line typescript/no-unnecessary-condition -- defensive check kept for Schema values that bypass zod deserialization (e.g. hand-constructed by consumers of this package) and so may not actually carry `shape`
       const itemType = prop.shape ? mapSchemaTypeToTypeScript(prop.shape, depth) : "any";
       return `${itemType}[]`;
     }
     case "object": {
+      // oxlint-disable-next-line typescript/no-unnecessary-condition -- defensive check kept for Schema values that bypass zod deserialization (e.g. hand-constructed by consumers of this package) and so may not actually carry `shape`
       if (prop.shape && typeof prop.shape === "object") {
         return generateObjectTypeWithJSDoc(prop.shape, depth);
       }
@@ -33,7 +35,7 @@ export function mapSchemaTypeToTypeScript(prop: PropertySchema, depth: number =
       return "object";
     }
     case "record": {
-      const valueType = prop.shape ? mapSchemaTypeToTypeScript(prop.shape) : "any";
+      const valueType = mapSchemaTypeToTypeScript(prop.shape);
       return `Record<string, ${valueType}>`;
     }
     case "function":
@@ -74,22 +76,21 @@ export function generatePropertyJSDoc(_propertyName: string, propertySchema: Pro
   }
 
   // Add @property tags for nested object properties (recursive!)
-  let hasNestedProperties = false;
+  // oxlint-disable-next-line typescript/no-unnecessary-condition -- defensive check kept for Schema values that bypass zod deserialization and so may not actually carry `shape`
   if (propertySchema.type === "object" && propertySchema.shape) {
     comments.push("");
     Object.entries(propertySchema.shape).forEach(([key, value]) => {
       if (value.description) {
         comments.push(`@property ${key} ${value.description}`);
-        hasNestedProperties = true;
       }
     });
+    // oxlint-disable-next-line typescript/no-unnecessary-condition -- defensive check kept for Schema values that bypass zod deserialization and so may not actually carry `shape`
   } else if (propertySchema.type === "array" && propertySchema.shape.type === "object" && propertySchema.shape.shape) {
     // For arrays of objects, document the object structure
     comments.push("");
     Object.entries(propertySchema.shape.shape).forEach(([key, value]) => {
       if (value.description) {
         comments.push(`@property ${key} ${value.description}`);
-        hasNestedProperties = true;
       }
     });
   }
@@ -100,7 +101,7 @@ export function generatePropertyJSDoc(_propertyName: string, propertySchema: Pro
   }
 
   // Single-line JSDoc
-  if (comments.length === 1 && !hasNestedProperties) {
+  if (comments.length === 1) {
     return `${indent}/** ${comments[0]} */\n`;
   }
 

package/src/compile/compile.ts

@@ -34,7 +34,7 @@ type CompilableExpression = Expression | PrivateIdentifier | Super | JSXElement
 export function compile(ast: Program): string {
   const localFunctions = new Set<string>();
   for (const stmt of ast.body) {
-    if (stmt.type === "FunctionDeclaration" && stmt.id) {
+    if (stmt.type === "FunctionDeclaration") {
       localFunctions.add(stmt.id.name);
     }
   }
@@ -54,7 +54,7 @@ export function compile(ast: Program): string {
       parts.push(`return ${emitJsxRoot(statement.expression, localFunctions)};`);
     } else if (!hasDeclarations && statement.type === "BlockStatement" && statement.body.length === 1) {
       const innerStatement = statement.body[0];
-      if (innerStatement.type === "ExpressionStatement") {
+      if (innerStatement?.type === "ExpressionStatement") {
         const syntheticContainer = {
           type: "JSXExpressionContainer" as const,
           expression: innerStatement.expression as CompilableExpression,
@@ -129,17 +129,19 @@ function emitAttributes(attributes: Array<JSXAttribute | JSXSpreadAttribute>, lo
       continue;
     }
 
+    // oxlint-disable-next-line typescript/no-unnecessary-condition -- attribute is only asserted (not runtime-validated) as JSXAttribute; acorn-typescript's real JSX grammar can still produce other AST shapes here
     if (attribute.type !== "JSXAttribute") {
       throw CompilationError.fromNode("Only simple JSX attributes allowed", attribute);
     }
 
-    const key = attribute.name?.name;
+    const key = attribute.name.name;
 
     let value: string = "";
     if (!attribute.value) {
       value = "true";
     } else if (attribute.value.type === "Literal") {
       value = JSON.stringify(attribute.value.value);
+      // oxlint-disable-next-line typescript/no-unnecessary-condition -- attribute.value is only asserted (not runtime-validated) as JSXAttributeValue; the real grammar can still produce other expression container contents here
     } else if (attribute.value.type === "JSXExpressionContainer") {
       value = emitExpression(attribute.value.expression, localFunctions);
     } else {
@@ -156,7 +158,7 @@ function emitAttributes(attributes: Array<JSXAttribute | JSXSpreadAttribute>, lo
   }
 
   if (parts.length === 1) {
-    return parts[0];
+    return parts[0] ?? "null";
   }
 
   return `Object.assign({}, ${parts.join(", ")})`;
@@ -197,8 +199,9 @@ function emitExpression(node: CompilableExpression, localFunctions: Set<string>)
       const bits: Array<string> = [];
       node.quasis.forEach((quasi, index) => {
         bits.push(JSON.stringify(quasi.value.cooked ?? ""));
-        if (node.expressions.length > index) {
-          bits.push(`+(${emitExpression(node.expressions[index], localFunctions)})+`);
+        const expression = node.expressions[index];
+        if (expression !== undefined) {
+          bits.push(`+(${emitExpression(expression, localFunctions)})+`);
         }
       });
       return bits.join("").replace(TRAILING_PLUS_RX, "") || '""';
@@ -272,7 +275,7 @@ function emitExpression(node: CompilableExpression, localFunctions: Set<string>)
     case "JSXEmptyExpression":
       return "null";
     default:
-      throw CompilationError.fromNode(`Unsupported expression: ${node?.type}`, node);
+      throw CompilationError.fromNode(`Unsupported expression: ${node.type}`, node);
   }
 }
 
@@ -347,6 +350,7 @@ function emitParam(param: Pattern, localFunctions: Set<string>): string {
 function getAstKeyString(node: Identifier | Literal): string {
   if (node.type === "Identifier") {
     return node.name;
+    // oxlint-disable-next-line typescript/no-unnecessary-condition -- node is only asserted (not runtime-validated) as Identifier | Literal at the call sites; the real ESTree key/property type is broader
   } else if (node.type === "Literal") {
     return JSON.stringify(node.value);
   } else {

package/src/jsx.ts

@@ -98,11 +98,11 @@ export type JSXNodeWithChildren = JSXElement | JSXFragment;
 export type JSXLeafNode = JSXText | JSXEmptyExpression;
 
 export function isJsxElement(value: unknown): value is JSXElement {
-  return (value as JSXElement)?.type === "JSXElement";
+  return (value as JSXElement | null | undefined)?.type === "JSXElement";
 }
 
 export function isJsxFragment(value: unknown): value is JSXFragment {
-  return (value as JSXFragment)?.type === "JSXFragment";
+  return (value as JSXFragment | null | undefined)?.type === "JSXFragment";
 }
 
 export function isJsxRoot(value: unknown): value is JSXRoot {
@@ -110,21 +110,21 @@ export function isJsxRoot(value: unknown): value is JSXRoot {
 }
 
 export function isJsxAttribute(value: unknown): value is JSXAttribute {
-  return (value as JSXAttribute)?.type === "JSXAttribute";
+  return (value as JSXAttribute | null | undefined)?.type === "JSXAttribute";
 }
 
 export function isJsxExpressionContainer(value: unknown): value is JSXExpressionContainer {
-  return (value as JSXExpressionContainer)?.type === "JSXExpressionContainer";
+  return (value as JSXExpressionContainer | null | undefined)?.type === "JSXExpressionContainer";
 }
 
 export function isJsxEmptyExpression(value: unknown): value is JSXEmptyExpression {
-  return (value as JSXEmptyExpression)?.type === "JSXEmptyExpression";
+  return (value as JSXEmptyExpression | null | undefined)?.type === "JSXEmptyExpression";
 }
 
 export function isJsxText(value: unknown): value is JSXText {
-  return (value as JSXText)?.type === "JSXText";
+  return (value as JSXText | null | undefined)?.type === "JSXText";
 }
 
 export function isJsxLeafNode(value: JSXNode): value is JSXLeafNode {
-  return (value as JSXText)?.type === "JSXText" || isJsxEmptyExpression(value);
+  return value.type === "JSXText" || isJsxEmptyExpression(value);
 }

package/src/parse/parse.ts

@@ -30,7 +30,7 @@ export function parse(source: string): Program {
 const ACORN_LOCATION_SUFFIX_RX = /\s+\(\d+:\d+\)$/;
 
 function isAcornError(error: unknown): error is AcornError {
-  return error instanceof Error && (error as AcornError).loc !== undefined;
+  return error instanceof Error && (error as Partial<AcornError>).loc !== undefined;
 }
 
 type AcornError = Error & {