@weft-js/cli 0.1.1 → 0.1.3

package/src/infer/worker.cjs

@@ -11,7 +11,11 @@ const { Session } = require('./session.cjs')
 const { root, write, debounce = 25, settle = 400, rest = 120_000 } = workerData
 const session = new Session(ts, root)
 const pending = new Set()
-let timer = null, running = false, last = '', writes = null, resting = null
+let timer = null,
+  running = false,
+  last = '',
+  writes = null,
+  resting = null
 
 function publish(list) {
   const text = JSON.stringify(list)
@@ -24,13 +28,28 @@ function publish(list) {
   return true
 }
 
-const applyEdits = (text, edits) => [...edits].sort((a, b) => b.start - a.start).reduce((t, e) => t.slice(0, e.start) + e.text + t.slice(e.end), text)
+const applyEdits = (text, edits) =>
+  [...edits]
+    .sort((a, b) => b.start - a.start)
+    .reduce((t, e) => t.slice(0, e.start) + e.text + t.slice(e.end), text)
 
 /** Exported types go into the source once the file has been quiet, and only if it's still the text they were made from. */
 function scheduleWrites(findings) {
   clearTimeout(writes)
   if (!write) return
-  const jobs = [...findings].flatMap(([file, list]) => { const edits = list.filter(f => f.safe && f.edits).flatMap(f => f.edits); return edits.length ? [{ file, edits, hash: session.engine.facts.get(file)?.hash, codes: list.map(f => f.code) }] : [] })
+  const jobs = [...findings].flatMap(([file, list]) => {
+    const edits = list.filter((f) => f.safe && f.edits).flatMap((f) => f.edits)
+    return edits.length
+      ? [
+          {
+            file,
+            edits,
+            hash: session.engine.facts.get(file)?.hash,
+            codes: list.map((f) => f.code),
+          },
+        ]
+      : []
+  })
   if (!jobs.length) return
   writes = setTimeout(() => {
     for (const job of jobs) {
@@ -51,18 +70,39 @@ function rested() {
 
 async function first() {
   running = true
-  try { await report(performance.now()) } catch (e) { parentPort.postMessage({ type: 'failed', message: e.stack }) } finally { running = false }
+  try {
+    await report(performance.now())
+  } catch (e) {
+    parentPort.postMessage({ type: 'failed', message: e.stack })
+  } finally {
+    running = false
+  }
   await drain()
 }
 
 async function report(t, files) {
   const { findings, errors } = await session.analyze(files)
   const flat = []
-  for (const [file, list] of [...findings, ...errors]) for (const f of list) flat.push({ file: relative(root, file), line: session.engine.texts.get(file).slice(0, f.start).split('\n').length, code: f.code, severity: f.severity ?? 'error', why: f.why, help: f.help })
+  for (const [file, list] of [...findings, ...errors])
+    for (const f of list)
+      flat.push({
+        file: relative(root, file),
+        line: session.engine.texts.get(file).slice(0, f.start).split('\n').length,
+        code: f.code,
+        severity: f.severity ?? 'error',
+        why: f.why,
+        help: f.help,
+      })
   scheduleWrites(findings)
   const changed = publish(flat)
   rested()
-  parentPort.postMessage({ type: 'done', ms: performance.now() - t, at: Date.now(), changed, diagnostics: flat })
+  parentPort.postMessage({
+    type: 'done',
+    ms: performance.now() - t,
+    at: Date.now(),
+    changed,
+    diagnostics: flat,
+  })
 }
 
 async function drain() {
@@ -76,7 +116,10 @@ async function drain() {
       let changed = false
       for (const f of files) if (session.engine.set(f)) changed = true
       if (session.host) session.touch(files)
-      if (!changed || !files.some(f => session.engine.relevant(f))) { parentPort.postMessage({ type: 'idle', ms: performance.now() - t }); continue }
+      if (!changed || !files.some((f) => session.engine.relevant(f))) {
+        parentPort.postMessage({ type: 'idle', ms: performance.now() - t })
+        continue
+      }
       await report(t, files)
     }
   } catch (e) {
@@ -86,8 +129,13 @@ async function drain() {
   }
 }
 
-parentPort.on('message', msg => {
-  if (msg === 'close') { clearTimeout(timer); clearTimeout(writes); session.close(); process.exit(0) }
+parentPort.on('message', (msg) => {
+  if (msg === 'close') {
+    clearTimeout(timer)
+    clearTimeout(writes)
+    session.close()
+    process.exit(0)
+  }
   pending.add(msg)
   clearTimeout(timer)
   timer = setTimeout(() => void drain(), debounce)

package/src/jsx-scan.mjs

@@ -16,51 +16,53 @@ import ts from 'typescript'
  * @returns {{ imports: Import[], elements: Element[], functions: Map<string, string> }}
  */
 export function scanJsx(text, file = 'file.tsx') {
-  const sf = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, file.endsWith('.jsx') ? ts.ScriptKind.JSX : ts.ScriptKind.TSX)
+  const sf = ts.createSourceFile(
+    file,
+    text,
+    ts.ScriptTarget.Latest,
+    true,
+    file.endsWith('.jsx') ? ts.ScriptKind.JSX : ts.ScriptKind.TSX,
+  )
   const imports = []
   const elements = []
   const functions = new Map()
   const stack = []
 
-  const attrsOf = attributes =>
-    attributes.properties.map(p => {
-      if (ts.isJsxSpreadAttribute(p)) return { name: '...', kind: 'spread', expr: p.expression.getText(sf), start: p.getStart(sf), end: p.end }
-      const name = p.name.getText(sf)
-      const base = { name, start: p.getStart(sf), end: p.end }
-      if (!p.initializer) return { ...base, kind: 'bool' }
-      if (ts.isStringLiteral(p.initializer)) return { ...base, kind: 'string', value: p.initializer.text, valueStart: p.initializer.getStart(sf), valueEnd: p.initializer.end }
-      const e = p.initializer.expression
-      if (e && (ts.isStringLiteral(e) || ts.isNoSubstitutionTemplateLiteral(e))) return { ...base, kind: 'string', value: e.text, valueStart: e.getStart(sf), valueEnd: e.end }
-      return { ...base, kind: 'expr', expr: e ? e.getText(sf) : '', valueStart: e?.getStart(sf), valueEnd: e?.end }
-    })
-
   const record = (open, node) => {
-    const attrs = attrsOf(open.attributes)
+    const attrs = attrsOf(sf, open.attributes)
     const el = {
       name: open.tagName.getText(sf),
       attrs,
-      attr: n => attrs.find(a => a.name === n),
+      attr: (n) => attrs.find((a) => a.name === n),
       ancestors: [...stack],
       start: node.getStart(sf),
       end: node.end,
       tagEnd: open.tagName.end,
-      children: ts.isJsxElement(node) ? node.children.map(c => c.getText(sf)).join('') : '',
+      children: ts.isJsxElement(node) ? node.children.map((c) => c.getText(sf)).join('') : '',
     }
     elements.push(el)
     return el
   }
 
-  const visit = node => {
+  const visit = (node) => {
     if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
       const source = node.moduleSpecifier.text
       const c = node.importClause
       const at = { source, start: node.getStart(sf), end: node.end }
       if (c?.name) imports.push({ local: c.name.text, ...at })
-      if (c?.namedBindings && ts.isNamedImports(c.namedBindings)) for (const s of c.namedBindings.elements) imports.push({ local: s.name.text, imported: s.propertyName?.text ?? s.name.text, ...at })
+      if (c?.namedBindings && ts.isNamedImports(c.namedBindings))
+        for (const s of c.namedBindings.elements)
+          imports.push({ local: s.name.text, imported: s.propertyName?.text ?? s.name.text, ...at })
       if (!c) imports.push({ local: '', ...at })
     }
-    if (ts.isFunctionDeclaration(node) && node.name && node.body) functions.set(node.name.text, node.body.getText(sf))
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
+    if (ts.isFunctionDeclaration(node) && node.name && node.body)
+      functions.set(node.name.text, node.body.getText(sf))
+    if (
+      ts.isVariableDeclaration(node) &&
+      ts.isIdentifier(node.name) &&
+      node.initializer &&
+      (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))
+    ) {
       functions.set(node.name.text, node.initializer.body.getText(sf))
     }
     if (ts.isJsxSelfClosingElement(node)) {
@@ -82,5 +84,45 @@ export function scanJsx(text, file = 'file.tsx') {
 /** The import an identifier in an expression (`{hero}`, `{hero.src}`) comes from, or undefined. */
 export function importOf(scan, expr) {
   const id = /^\s*([A-Za-z_$][\w$]*)/.exec(expr ?? '')?.[1]
-  return id ? scan.imports.find(i => i.local === id) : undefined
+  return id ? scan.imports.find((i) => i.local === id) : undefined
+}
+
+function attrsOf(sf, attributes) {
+  return attributes.properties.map((p) => {
+    if (ts.isJsxSpreadAttribute(p))
+      return {
+        name: '...',
+        kind: 'spread',
+        expr: p.expression.getText(sf),
+        start: p.getStart(sf),
+        end: p.end,
+      }
+    const name = p.name.getText(sf)
+    const base = { name, start: p.getStart(sf), end: p.end }
+    if (!p.initializer) return { ...base, kind: 'bool' }
+    if (ts.isStringLiteral(p.initializer))
+      return {
+        ...base,
+        kind: 'string',
+        value: p.initializer.text,
+        valueStart: p.initializer.getStart(sf),
+        valueEnd: p.initializer.end,
+      }
+    const e = p.initializer.expression
+    if (e && (ts.isStringLiteral(e) || ts.isNoSubstitutionTemplateLiteral(e)))
+      return {
+        ...base,
+        kind: 'string',
+        value: e.text,
+        valueStart: e.getStart(sf),
+        valueEnd: e.end,
+      }
+    return {
+      ...base,
+      kind: 'expr',
+      expr: e ? e.getText(sf) : '',
+      valueStart: e?.getStart(sf),
+      valueEnd: e?.end,
+    }
+  })
 }

package/src/load-config/schema.mjs

@@ -0,0 +1,281 @@
+function baseSchemas(z) {
+  const zodSchema = z.custom(
+    (v) => v != null && typeof v === 'object' && ('_zod' in v || '~standard' in v),
+  )
+  const globs = z.array(z.string())
+
+  const task = z.strictObject({
+    run: z.string().min(1),
+    description: z.string().optional(),
+    sideEffects: z.array(z.string()).optional(),
+    env: z.array(z.string()).optional(),
+    args: z.union([zodSchema, z.record(z.string(), z.unknown())]).optional(),
+  })
+
+  const pluginEntry = z.looseObject({
+    name: z.string().min(1),
+    version: z.string().optional(),
+    provides: z
+      .array(z.union([z.string(), z.strictObject({ slot: z.string(), key: z.string() })]))
+      .optional(),
+  })
+
+  const image = z.strictObject({
+    url: z.string().min(1),
+    width: z.int().positive().optional(),
+    height: z.int().positive().optional(),
+    alt: z.string().optional(),
+  })
+
+  const hex = z.string().regex(/^#[0-9a-fA-F]{6}$/, { error: 'must be #rrggbb' })
+  const colors = {
+    background: hex.optional(),
+    text: hex.optional(),
+    subtle: hex.optional(),
+    accent: hex.optional(),
+  }
+  const cardFont = z.strictObject({
+    family: z.string().regex(/^[\w -]+$/, { error: 'must be a font family name' }),
+    src: z.string().min(1),
+    weight: z.number().optional(),
+  })
+  const card = z.strictObject({
+    ...colors,
+    scheme: z.enum(['dark', 'light']).optional(),
+    dark: z.strictObject(colors).optional(),
+    light: z.strictObject(colors).optional(),
+    fonts: z.strictObject({ display: cardFont.optional(), body: cardFont.optional() }).optional(),
+  })
+
+  const site = z.strictObject({
+    headers: z.record(z.string(), z.record(z.string(), z.string())).optional(),
+    name: z.string().min(1).optional(),
+    url: z.url({ protocol: /^https?$/, error: 'must be an absolute http(s) URL' }).optional(),
+    title: z.string().includes('%s', { error: 'must contain `%s` (the page title)' }).optional(),
+    description: z.string().optional(),
+    locale: z
+      .string()
+      .regex(/^[a-z]{2,3}(_[A-Z]{2})?$/, { error: 'must look like `en_US`' })
+      .optional(),
+    inlineCss: z.boolean().optional(),
+    criticalCss: z.boolean().optional(),
+    criticalKeep: z.array(z.string()).optional(),
+    image: z.union([z.literal('auto'), z.literal(false), z.string().min(1), image]).optional(),
+    card: card.optional(),
+    head: z.string().optional(),
+    twitter: z
+      .strictObject({
+        card: z.enum(['summary', 'summary_large_image', 'app', 'player']).optional(),
+        site: z.string().optional(),
+        creator: z.string().optional(),
+      })
+      .optional(),
+  })
+
+  return { globs, task, pluginEntry, site }
+}
+
+function mainProperties(z, { globs, task, pluginEntry, site }) {
+  return {
+    scope: z
+      .strictObject({ write: globs.optional(), read: globs.optional(), forbid: globs.optional() })
+      .optional(),
+    tasks: z.record(z.string(), task).optional(),
+    environments: z.record(z.string(), z.looseObject({ url: z.string().optional() })).optional(),
+    test: z
+      .strictObject({
+        include: globs.optional(),
+        lanes: z.array(z.enum(['fast', 'browser', 'e2e'])).optional(),
+        gate: z
+          .strictObject({
+            mutationBudgetSec: z.number().positive().optional(),
+            maxMutants: z.number().int().positive().optional(),
+          })
+          .optional(),
+      })
+      .optional(),
+    build: z
+      .strictObject({
+        audit: z
+          .union([
+            z.boolean(),
+            z.strictObject({
+              routes: z.array(z.string()).optional(),
+              all: z.boolean().optional(),
+              max: z.number().int().positive().optional(),
+              indexing: z.enum(['auto', 'public', 'private']).optional(),
+            }),
+          ])
+          .optional(),
+        unsafeAllow: z
+          .record(
+            z.string().regex(/^(all|[A-Z]|[A-Z]+\d{3})$/, 'a code (R002), a family (L) or all'),
+            z.string().min(1, 'say why'),
+          )
+          .optional(),
+      })
+      .optional(),
+    check: z
+      .strictObject({
+        include: globs.optional(),
+        exclude: globs.optional(),
+        design: z.boolean().optional(),
+        routes: z.boolean().optional(),
+        props: z.union([z.boolean(), z.literal('manual')]).optional(),
+      })
+      .optional(),
+    plugins: z.array(pluginEntry).optional(),
+    slots: z.record(z.string(), z.union([z.string(), z.record(z.string(), z.string())])).optional(),
+    site: site.optional(),
+    runtime: z.enum(['node', 'bun', 'deno']).optional(),
+    hydration: z.enum(['lazy', 'partial', 'full']).optional(),
+    rust: z
+      .strictObject({
+        unions: z.literal('allow').optional(),
+        services: z
+          .record(
+            z.string(),
+            z.strictObject({
+              crate: z.string().optional(),
+              external: z.boolean().optional(),
+              wasm: z.literal(false).optional(),
+            }),
+          )
+          .optional(),
+      })
+      .optional(),
+  }
+}
+
+function deployFirst(z) {
+  return {
+    target: z.enum(['netlify', 'vercel', 'cloudflare', 'fly', 'render']).optional(),
+    netlify: z.strictObject({ site: z.string().min(1).optional() }).optional(),
+    vercel: z
+      .strictObject({
+        project: z
+          .string()
+          .regex(/^[a-z0-9][a-z0-9-]{0,62}$/i, 'a name: letters, digits and dashes')
+          .optional(),
+      })
+      .optional(),
+    cloudflare: z
+      .strictObject({
+        name: z
+          .string()
+          .regex(/^[a-z0-9][a-z0-9-]{0,62}$/i, 'a name: letters, digits and dashes')
+          .optional(),
+      })
+      .optional(),
+  }
+}
+
+function deployFly(z) {
+  return {
+    fly: z
+      .strictObject({
+        app: z
+          .string()
+          .regex(/^[a-z0-9][a-z0-9-]{0,62}$/i, 'a name: letters, digits and dashes')
+          .optional(),
+        region: z
+          .string()
+          .regex(/^[a-z]{3}$/, 'a Fly region code, like `iad`')
+          .optional(),
+        memory: z
+          .string()
+          .regex(/^\d+(mb|gb)$/, 'like `512mb`')
+          .optional(),
+        volume: z
+          .strictObject({
+            name: z
+              .string()
+              .regex(/^[a-z0-9_]+$/, 'lowercase letters, digits and underscores')
+              .optional(),
+            path: z.string().startsWith('/').optional(),
+            sizeGb: z.number().int().positive().optional(),
+          })
+          .optional(),
+      })
+      .optional(),
+  }
+}
+
+function deployRest(z) {
+  return {
+    render: z
+      .strictObject({
+        service: z
+          .string()
+          .regex(/^[a-z0-9][a-z0-9-]{0,62}$/i, 'a name: letters, digits and dashes')
+          .optional(),
+        plan: z.string().optional(),
+        region: z.string().optional(),
+        disk: z
+          .strictObject({
+            path: z.string().startsWith('/').optional(),
+            sizeGb: z.number().int().positive().optional(),
+          })
+          .optional(),
+      })
+      .optional(),
+    ci: z.union([z.literal('github'), z.literal(false)]).optional(),
+    branch: z.string().min(1).optional(),
+    cdn: z
+      .strictObject({
+        proxy: z.literal('cloudflare').optional(),
+        images: z
+          .strictObject({
+            provider: z.literal('cloudinary'),
+            cloud: z
+              .string()
+              .regex(/^[\w-]+$/, "the cloud's name, not its URL")
+              .optional(),
+          })
+          .optional(),
+      })
+      .optional(),
+  }
+}
+
+function deploySchema(z) {
+  return z.strictObject({ ...deployFirst(z), ...deployFly(z), ...deployRest(z) }).optional()
+}
+
+function remainingProperties(z) {
+  return {
+    /** Named targets for a query's `live: { verify: 'staging' }`. `db` is an env var's name. */
+    live: z
+      .strictObject({
+        targets: z
+          .record(
+            z.string(),
+            z.strictObject({
+              url: z.string().optional(),
+              db: z.string().optional(),
+              production: z.boolean().optional(),
+            }),
+          )
+          .optional(),
+      })
+      .optional(),
+    trust: z.enum(['enforce', 'warn']).optional(),
+  }
+}
+
+export function createSchemas(z) {
+  const base = baseSchemas(z)
+  const configSchema = z.strictObject({
+    ...mainProperties(z, base),
+    deploy: deploySchema(z),
+    ...remainingProperties(z),
+  })
+  const { pluginEntry } = base
+  const dataSchema = configSchema.extend({
+    $schema: z.string().optional(),
+    plugins: z
+      .array(z.union([z.string(), z.tuple([z.string(), z.unknown()]), pluginEntry]))
+      .optional(),
+  })
+  return { configSchema, dataSchema }
+}