@crossworks/app-build 0.239.8 → 0.239.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crossworks/app-build",
-  "version": "0.239.8",
+  "version": "0.239.9",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -11,7 +11,7 @@
     "src"
   ],
   "dependencies": {
-    "@mantle/share-ui": "npm:@crossworks/share-ui@0.239.8",
+    "@mantle/share-ui": "npm:@crossworks/share-ui@0.239.9",
     "@tailwindcss/oxide": "^4.3.3",
     "esbuild": "^0.28.2",
     "lucide-react": "^1.41.0",

package/src/index.ts

@@ -219,15 +219,29 @@ export function lintToolRefs(source: AppSource, declaredSlugs: string[]): BuildM
  *  and named (including a default+named combination). */
 const IMPORT_RE = /import\s+([^'";]+?)\s+from\s*['"]([^'"]+)['"]/g;
 
+/** `import type …` — the whole clause is type-only. Lookahead keeps
+ *  `import type from 'm'` and `import type, { a } from 'm'` (a default import
+ *  that happens to be NAMED `type`) as value imports. */
+const TYPE_ONLY_CLAUSE_RE = /^type(?=\s*[{*]|\s+[A-Za-z_$])/;
+
+/** `{ type X }` / `{ type X as Y }` — one type-only specifier. `{ type }` and
+ *  `{ type as t }` import a value named `type` and stay checked. */
+const TYPE_ONLY_SPECIFIER_RE = /^type\s+(?!as\b)[A-Za-z_$]/;
+
 /** Split an import clause into the names it binds FROM the module.
  *  `Foo`               → default
  *  `* as ns`           → namespace (binds nothing by name; nothing to check)
  *  `{ a, b as c }`     → a, b
  *  `Foo, { a }`        → default, a
- *  Returns the names as the MODULE must provide them, not the local aliases. */
+ *  `type { A }`        → nothing (type-only)
+ *  `{ type A, b }`     → b
+ *  Returns the names as the MODULE must provide them, not the local aliases.
+ *  Type-only imports and specifiers are skipped: the compiler erases them, so
+ *  they never reach the runtime and cannot fail to link. */
 function importedNames(clause: string): { names: string[]; namespace: boolean } {
   const names: string[] = [];
   let namespace = false;
+  if (TYPE_ONLY_CLAUSE_RE.test(clause)) return { names, namespace };
   const braced = clause.match(/\{([^}]*)\}/);
   const head = clause
     .slice(0, braced ? clause.indexOf('{') : undefined)
@@ -239,6 +253,7 @@ function importedNames(clause: string): { names: string[]; namespace: boolean }
   }
   if (braced) {
     for (const part of braced[1]!.split(',')) {
+      if (TYPE_ONLY_SPECIFIER_RE.test(part.trim())) continue;
       const name = (part.split(/\s+as\s+/)[0] ?? '').trim();
       if (name) names.push(name);
     }
@@ -262,7 +277,8 @@ function importedNames(clause: string): { names: string[]; namespace: boolean }
  * Errors, not warnings: the app is guaranteed not to run.
  *
  * Local/relative imports are the bundler's business and are skipped, as is a
- * namespace import (`* as ns`), which binds no names and cannot mismatch.
+ * namespace import (`* as ns`), which binds no names and cannot mismatch, and
+ * any type-only import or specifier, which the compiler erases.
  */
 export function lintRuntimeImports(
   source: AppSource,

package/src/runtime-imports.test.ts

@@ -71,6 +71,79 @@ describe('lintRuntimeImports', () => {
   });
 });
 
+describe('lintRuntimeImports: type-only imports', () => {
+  // The compiler erases these, so they never reach the runtime and cannot
+  // fail to link. The field case: an admin app's `import type { ReactNode }`.
+  const lint = (text: string) => lintRuntimeImports(src({ 'a.tsx': text }), RT);
+
+  it.each([
+    "import type { ReactNode } from 'react';\n",
+    "import type { ReactNode, FC as F } from 'react';\n",
+    "import type React from 'react';\n",
+    "import type * as R from 'react';\n",
+    "import type{ReactNode}from 'react';\n",
+    "import { type ReactNode } from 'react';\n",
+    "import { type ReactNode, type FC as F } from 'react';\n",
+    "import React, { type ReactNode } from 'react';\n",
+    "export type { ReactNode } from 'react';\n",
+  ])('skips %s', (text) => {
+    expect(lint(text)).toEqual([]);
+  });
+
+  it('still checks the value part of a mixed import', () => {
+    expect(lint("import { type ReactNode, useState } from 'react';\n")).toEqual([]);
+    const msgs = lint("import { type ReactNode, nope } from 'react';\n");
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]!.text).toContain("'react' does not export 'nope'");
+  });
+
+  it('treats a binding NAMED `type` as a value import', () => {
+    // `import type from` / `import type, {…}` = default import called `type`.
+    expect(lint("import type from '@host';\n")[0]!.text).toContain("'@host' has no default export");
+    expect(lint("import type, { host } from '@host';\n")).toHaveLength(1);
+    // `{ type }` / `{ type as t }` = named import of an export called `type`.
+    expect(lint("import { type } from '@host';\n")[0]!.text).toContain(
+      "'@host' does not export 'type'",
+    );
+    expect(lint("import { type as t } from '@host';\n")).toHaveLength(1);
+  });
+});
+
+describe('buildApp: type-only imports', () => {
+  const app = (head: string) =>
+    src({ 'App.tsx': `${head}\nexport default function App(){return <div/>;}\n` });
+
+  it.each([
+    "import type { ReactNode } from 'react';",
+    "import { type ReactNode } from 'react';",
+    "import { type ReactNode, useState } from 'react'; console.log(useState);",
+    "export type { ReactNode } from 'react';",
+  ])('builds with %s', async (head) => {
+    const res = await buildApp(app(head), { runtimeExports: RT });
+    expect(res.errors).toEqual([]);
+    expect(res.ok).toBe(true);
+  });
+
+  it.each([
+    "import type { ZodType } from 'zod';",
+    "import { type ZodType } from 'zod';",
+    "export type { ZodType } from 'zod';",
+  ])('allows a disallowed package imported type-only: %s', async (head) => {
+    const res = await buildApp(app(head), { runtimeExports: RT });
+    expect(res.errors).toEqual([]);
+    expect(res.ok).toBe(true);
+  });
+
+  it.each([
+    "import { z } from 'zod'; console.log(z);",
+    "import { type ZodType, z } from 'zod'; console.log(z);",
+  ])('refuses the same package imported as a value: %s', async (head) => {
+    const res = await buildApp(app(head), { runtimeExports: RT });
+    expect(res.ok).toBe(false);
+    expect(res.errors[0]!.text).toContain("Import 'zod' is not allowed in a mini app");
+  });
+});
+
 describe('buildApp — runtime import check', () => {
   it('FAILS the build rather than publishing an app that cannot link', async () => {
     const res = await buildApp(