lecodes-cli 2.0.3 → 2.0.4

package/src/commands/update/index.ts

@@ -25,7 +25,8 @@ import app from "../app"
  *   6. cli       the npm installs — every installed optional peer (lecodes-headless, lecodes-design,
  *                lecodes-3d-editor, lecodes-assets, @napi-rs/canvas) and the CLI itself that is behind:
  *                peers in ~/.lecodes/peers (first-use installs, peerInstall.ts) are re-installed there
- *                — the renderer at THIS CLI's version, the rest at npm's latest in range; global ones
+ *                — the renderer at THIS CLI's version, an editor at the newest one out that this
+ *                CLI's peer range takes, the rest at npm's latest in range; global ones
  *                (`npm install -g`, the old way) via `npm install -g …@latest`; the CLI itself last
  *                (the standalone binary can't come from npm — it says so and does the peers only)
  *
@@ -175,9 +176,9 @@ export default defineCommand({
         const where = peerSource(name, probe)
         const installed = peerVersion(name, probe)
         // an archived peer (the headless host, the editors) has no "latest" of a registry: the
-        // version this CLI is for is the one to have
+        // version this CLI installs is the one to have
         const latest = !installed ? null
-          : archivedVersion(name) ?? await npmLatest(name)
+          : await archivedVersion(name) ?? await npmLatest(name)
         rows.push({ name, installed, latest, where })
       }
       rows.push({ name: "lecodes-cli", installed: pkg.version, latest: await npmLatest("lecodes-cli"), where: "global" })
@@ -192,7 +193,7 @@ export default defineCommand({
       }
       if (behind.length === 0) return "ok"
       const prefixBehind = behind.filter((r) => r.where === "prefix")
-      const globalSpecs = behind.filter((r) => r.where !== "prefix").map((r) => archiveSpec(r.name) ?? r.name + "@latest")
+      const globalSpecs = await Promise.all(behind.filter((r) => r.where !== "prefix").map(async (r) => await archiveSpec(r.name) ?? r.name + "@latest"))
       if (flags.check) {
         return ["updated", behind.length + " behind — run: lecodes update" + (globalSpecs.length ? "  (global: npm install -g " + globalSpecs.join(" ") + ")" : "")]
       }

package/src/hosts/archives.ts

@@ -5,8 +5,10 @@ import pkg from "../../package.json"
  * `npm install <url>` puts the package in place under its own name.
  *
  * A url names one version, and which one is this CLI's to say: the headless host at the CLI's own
- * version (one ABI set), an editor at the version the CLI was published against (its peer range,
- * snapped to it by scripts/sync-peer-versions.ts). */
+ * version (one ABI set); an editor at the NEWEST version out that the CLI's peer range takes — the
+ * package's index.json in the bucket names what is out. So an editor is released with no release
+ * of the CLI: `lecodes update` brings it. With the index out of reach it is the range's own
+ * version, the one the CLI was published against (scripts/sync-peer-versions.ts). */
 
 export const ARCHIVED_PEERS: ReadonlySet<string> = new Set(["lecodes-headless", "lecodes-design", "lecodes-3d-editor"])
 
@@ -16,17 +18,49 @@ export const packagesBase = (): string => (process.env.LECODES_PACKAGES_URL || B
 
 export const archiveUrl = (name: string, version: string): string => `${packagesBase()}/${name}/${name}-${version}.tgz`
 
+const numbers = (version: string): number[] => version.split(/[.-]/).slice(0, 3).map(Number)
+const byVersion = (a: string, b: string): number => {
+  const pa = numbers(a), pb = numbers(b)
+  for (let i = 0; i < 3; i++) { const d = (pa[i] ?? 0) - (pb[i] ?? 0); if (d) return d }
+  return 0
+}
+
+/** `^floor` takes it: not older, and the same leftmost number that is not zero. */
+export const caretTakes = (floor: string, version: string): boolean => {
+  if (!/^\d+\.\d+\.\d+$/.test(version) || byVersion(version, floor) < 0) return false
+  const f = numbers(floor), v = numbers(version)
+  const held = f[0] ? 1 : f[1] ? 2 : 3
+  for (let i = 0; i < held; i++) if (f[i] !== v[i]) return false
+  return true
+}
+
+const asked = new Map<string, Promise<string[]>>()
+/** What is out of a package, as its index names it; none with the index out of reach. */
+const versionsOut = (name: string): Promise<string[]> => {
+  const url = `${packagesBase()}/${name}/index.json`
+  let answer = asked.get(url)
+  if (!answer) {
+    answer = fetch(`${url}?t=${Date.now()}`, { signal: AbortSignal.timeout(4000) })
+      .then(async (res) => res.ok ? ((await res.json()) as { versions?: string[] }).versions ?? [] : [])
+      .catch(() => [])
+    asked.set(url, answer)
+  }
+  return answer
+}
+
 /** The version of an archived peer this CLI installs; null for a peer that is none. */
-export const archivedVersion = (name: string): string | null => {
+export const archivedVersion = async (name: string): Promise<string | null> => {
   if (!ARCHIVED_PEERS.has(name)) return null
   if (name === "lecodes-headless") return pkg.version
   const range = (pkg.peerDependencies as Record<string, string> | undefined)?.[name]
-  const version = range?.replace(/^[\^~>=\s]+/, "")
-  return version && /^\d+\.\d+\.\d+/.test(version) ? version : null
+  const floor = range?.replace(/^[\^~>=\s]+/, "")
+  if (!floor || !/^\d+\.\d+\.\d+/.test(floor)) return null
+  const newest = (await versionsOut(name)).filter((version) => caretTakes(floor, version)).sort(byVersion).pop()
+  return newest ?? floor
 }
 
 /** What an archived peer is installed by; null for a peer that is none. */
-export const archiveSpec = (name: string): string | null => {
-  const version = archivedVersion(name)
+export const archiveSpec = async (name: string): Promise<string | null> => {
+  const version = await archivedVersion(name)
   return version ? archiveUrl(name, version) : null
 }

package/src/hosts/peerInstall.ts

@@ -31,10 +31,10 @@ const CANVAS_RANGE_FALLBACK = "^0.1.65"
 const readJson = (path: string): any => { try { return JSON.parse(readFileSync(path, "utf8")) } catch { return null } }
 
 /** What a peer installs by: the url of its archive — the renderer at exactly this CLI's version (one
- *  ABI set), an editor at the version this CLI was published against — or, for npm's, a spec: canvas
- *  at the range the installed renderer declares, lecodes-assets at this CLI's peer range. */
-export const peerSpec = (name: string): string => {
-  const archive = archiveSpec(name)
+ *  ABI set), an editor at the newest version out that this CLI's peer range takes — or, for npm's, a
+ *  spec: canvas at the range the installed renderer declares, lecodes-assets at this CLI's peer range. */
+export const peerSpec = async (name: string): Promise<string> => {
+  const archive = await archiveSpec(name)
   if (archive) return archive
   if (name === "@napi-rs/canvas") {
     const renderer = readJson(join(peerDirInPrefix("lecodes-headless"), "package.json"))
@@ -71,7 +71,7 @@ export const installPeers = async (names: string[], why: string, opts: { yes?: b
   }
   // The renderer must be in place before canvas's range can be read off it — install in order.
   const ordered = [...names].sort((a, b) => (a === "lecodes-headless" ? -1 : b === "lecodes-headless" ? 1 : 0))
-  const specsNow = ordered.map(peerSpec)
+  const specsNow = await Promise.all(ordered.map(peerSpec))
 
   const yes = opts.yes === true || !!process.env.LECODES_YES
   if (!yes) {
@@ -90,7 +90,7 @@ export const installPeers = async (names: string[], why: string, opts: { yes?: b
   if (!tool) throw new CliError(`Neither npm nor bun is on PATH, so ${names.join(" + ")} can't be installed automatically. Install one, or run on a machine with Node:  ${manualCommand(dir, specsNow)}`)
 
   for (const name of ordered) {
-    const spec = peerSpec(name) // canvas's range comes from the renderer installed a step earlier
+    const spec = await peerSpec(name) // canvas's range comes from the renderer installed a step earlier
     const argv = tool === "npm"
       ? ["install", "--prefix", dir, "--no-audit", "--no-fund", "--loglevel=error", spec]
       : ["add", "--cwd", dir, spec]
@@ -157,7 +157,7 @@ export async function loadPeer<T>(name: string, subpath: string | undefined, opt
     if (opts.install === false) return null
     // A global install of a DIFFERENT version than the probe expects would have resolved above; here
     // the peer is nowhere. (Globally installed but broken → the error above was not "not found".)
-    if (peerVersionGlobal(name, spec) !== null) throw new CliError(`${name} is installed but "${spec}" can't be loaded from it — reinstall it: npm install -g ${peerSpec(name)}`)
+    if (peerVersionGlobal(name, spec) !== null) throw new CliError(`${name} is installed but "${spec}" can't be loaded from it — reinstall it: npm install -g ${await peerSpec(name)}`)
     await installPeers(companions(name), opts.for)
   }
   return (await import(pathToFileURL(resolveEntry(dir, subpath)).href)) as T

package/src/web/build.ts

@@ -14,8 +14,12 @@ import { CliError } from "../cli"
  *
  *   index.html            the page (name, icon, theme color of app.json)
  *   app.<hash>.js         the bundle — the same code every platform runs
- *   lite.js, assets/…     the page of Web Lite (lecodes-web-lite's dist): its script, its font,
- *                         the tween engine
+ *   lite.js, assets/…     the page of Web Lite (lecodes-web-lite's dist): its script, its font
+ *                         in parts by script (a browser fetches the ones a page shows; none
+ *                         with app.json `web.font: "system"`)
+ *                         and the FEATURES this app needs (the pager, the virtualized list, the
+ *                         tweens, the canvas — a chunk each; the page's features.json says what
+ *                         a bundle has to name for one to be needed, and whose files they are)
  *   assets/<path>         the project's assets — only the ones the bundle names
  *   404.html              in `path` mode: the page again, for the hostings that answer an unknown
  *                         path with it
@@ -36,6 +40,10 @@ export type WebConfig = {
   themeColor?: string
   /** The page's language (`<html lang>`). */
   lang?: string
+  /** The font of a text that names none: `roboto` (default; the browser fetches the parts the
+   *  page shows) or `system` — the device's own font, nothing fetched, the width of a text the
+   *  device's. */
+  font?: "roboto" | "system"
 }
 
 export type WebBuildOptions = {
@@ -123,6 +131,17 @@ export const buildWeb = async (options: WebBuildOptions): Promise<WebBuildResult
   rmSync(out, { recursive: true, force: true })
   mkdirSync(out, { recursive: true })
   cpSync(lite, out, { recursive: true })
+  // the features this bundle never names are not part of its page
+  const table = join(out, "features.json")
+  if (existsSync(table)) {
+    const { features, fonts } = JSON.parse(readFileSync(table, "utf8")) as { features: { name: string, uses: string[], files: string[] }[], fonts?: string[] }
+    if (config.font === "system") for (const file of fonts ?? []) rmSync(join(out, file), { force: true })
+    for (const feature of features) {
+      if (feature.uses.some((name) => js.includes(name))) continue
+      for (const file of feature.files) rmSync(join(out, file), { force: true })
+    }
+    rmSync(table)
+  }
 
   const bundle = `app.${createHash("sha256").update(js).digest("hex").slice(0, 10)}.js`
   writeFileSync(join(out, bundle), js)
@@ -154,7 +173,11 @@ export const buildWeb = async (options: WebBuildOptions): Promise<WebBuildResult
   }
   // in path mode a route is a path: what the page names relatively is under the base, whatever the route
   if (mode === "path") head.unshift(`<base href="${escapeHtml(base)}" />`)
-  const attrs = [`data-src="${bundle}"`, ...(mode === "path" ? [`data-urls="path"`, `data-base="${escapeHtml(base)}"`] : [])].join(" ")
+  const attrs = [
+    `data-src="${bundle}"`,
+    ...(mode === "path" ? [`data-urls="path"`, `data-base="${escapeHtml(base)}"`] : []),
+    ...(config.font === "system" ? [`data-font="system"`] : []),
+  ].join(" ")
   const replace = (from: string | RegExp, to: string) => {
     const next = html.replace(from, to)
     if (next === html) throw new CliError(`The page of Web Lite has no ${String(from)} to fill — this CLI and its page are of different versions.`)