lecodes-sdk 1.2.0 → 2.0.1

package/src/compile/__tests__/assetIconMacro.test.ts

@@ -1,219 +0,0 @@
-import { test, expect, describe } from "bun:test"
-import { applyAssetIconMacro, buildIconsHeaderValue, iconNotFoundError, rewriteAssetIcons, scanAssetIconCalls, suggestIconNames } from "../assetIconMacro"
-
-const svg = (stroke: string) => `<svg viewBox="0 0 24 24"><path stroke="${stroke}" d="M1 1"/></svg>`
-
-describe("scanAssetIconCalls", () => {
-  test("a bare call → id + pack + name, no color, correct span", () => {
-    const src = `UIImage(assetIcon("lucide:bell"))`
-    const [c] = scanAssetIconCalls(src)
-    expect(c.id).toBe("lucide:bell")
-    expect(c.pack).toBe("lucide")
-    expect(c.name).toBe("bell")
-    expect(c.bake).toBeUndefined()
-    expect(c.tint).toBeUndefined()
-    expect(c.error).toBeUndefined()
-    expect(src.slice(c.start, c.end)).toBe(`assetIcon("lucide:bell")`)
-  })
-
-  test("a literal color option → captured as a compile-time bake", () => {
-    const [c] = scanAssetIconCalls(`assetIcon('lucide:check', { color: "#5b8cff" })`)
-    expect(c.id).toBe("lucide:check")
-    expect(c.bake).toBe("#5b8cff")
-    expect(c.tint).toBeUndefined()
-    expect(c.error).toBeUndefined()
-  })
-
-  test("a token / expression color → captured verbatim as a runtime tint (not an error)", () => {
-    const [c] = scanAssetIconCalls(`assetIcon("lucide:bell", { color: tokens.accent })`)
-    expect(c.tint).toBe("tokens.accent")
-    expect(c.bake).toBeUndefined()
-    expect(c.error).toBeUndefined()
-  })
-
-  test("dashed pack/name ids are valid", () => {
-    const [c] = scanAssetIconCalls(`assetIcon("simple-icons:arrow-right")`)
-    expect(c.pack).toBe("simple-icons")
-    expect(c.name).toBe("arrow-right")
-    expect(c.error).toBeUndefined()
-  })
-
-  test("a non-literal id → error", () => {
-    const [c] = scanAssetIconCalls(`assetIcon(iconVar)`)
-    expect(c.error).toContain("string-literal id")
-  })
-
-  test("a malformed id → error naming pack:name", () => {
-    const [c] = scanAssetIconCalls(`assetIcon("BellIcon")`)
-    expect(c.error).toContain("pack:name")
-  })
-
-  test("a non-object opts → error", () => {
-    const [c] = scanAssetIconCalls(`assetIcon("lucide:bell", "#fff")`)
-    expect(c.error).toContain("object literal")
-  })
-
-  test("a method named assetIcon is not matched", () => {
-    expect(scanAssetIconCalls(`icons.assetIcon("lucide:bell")`)).toEqual([])
-  })
-
-  test("assetIcon inside a string or comment is ignored", () => {
-    expect(scanAssetIconCalls(`const s = "assetIcon('lucide:bell')" // assetIcon('lucide:x')`)).toEqual([])
-  })
-
-  test("surrounding template literals don't confuse the scan", () => {
-    const src = "UIBox([]).style({ border: `2px solid ${c.muted}` })\nUIImage(assetIcon('lucide:bell'))"
-    const calls = scanAssetIconCalls(src)
-    expect(calls).toHaveLength(1)
-    expect(calls[0].id).toBe("lucide:bell")
-  })
-
-  test("multiple calls are all found in order", () => {
-    const calls = scanAssetIconCalls(`assetIcon("lucide:bell"); assetIcon("lucide:check")`)
-    expect(calls.map((c) => c.id)).toEqual(["lucide:bell", "lucide:check"])
-  })
-})
-
-describe("rewriteAssetIcons", () => {
-  test("rewrites a call to an inline SvgSource(...)", () => {
-    const src = `UIImage(assetIcon("lucide:bell"))`
-    const out = rewriteAssetIcons(src, scanAssetIconCalls(src), new Map([["lucide:bell", svg("currentColor")]]))
-    expect(out).toBe("UIImage(SvgSource(`" + svg("currentColor") + "`))")
-    expect(out).not.toContain("assetIcon")
-  })
-
-  test("bakes a literal color (currentColor → color)", () => {
-    const src = `assetIcon("lucide:bell", { color: "#f00" })`
-    const out = rewriteAssetIcons(src, scanAssetIconCalls(src), new Map([["lucide:bell", svg("currentColor")]]))
-    expect(out).toContain(`stroke="#f00"`)
-    expect(out).not.toContain("currentColor")
-    expect(out).not.toContain("tintColor")
-  })
-
-  test("a token color → source-level tint, SVG left as currentColor", () => {
-    const src = `assetIcon("lucide:bell", { color: colors.accent })`
-    const out = rewriteAssetIcons(src, scanAssetIconCalls(src), new Map([["lucide:bell", svg("currentColor")]]))
-    expect(out).toContain("Object.assign(SvgSource(`")
-    expect(out).toContain("{ tintColor: (colors.accent) }")
-    expect(out).toContain("currentColor")
-  })
-
-  test("escapes backticks and ${ in the SVG body", () => {
-    const nasty = "<svg>`${danger}`</svg>"
-    const src = `assetIcon("lucide:bell")`
-    const out = rewriteAssetIcons(src, scanAssetIconCalls(src), new Map([["lucide:bell", nasty]]))
-    expect(out).toContain("\\`")
-    expect(out).toContain("\\${")
-  })
-
-  test("two calls in one file are both rewritten (indices stay valid)", () => {
-    const src = `[assetIcon("lucide:bell"), assetIcon("lucide:check")]`
-    const map = new Map([["lucide:bell", svg("a")], ["lucide:check", svg("b")]])
-    const out = rewriteAssetIcons(src, scanAssetIconCalls(src), map)
-    expect(out).not.toContain("assetIcon")
-    expect(out).toContain(svg("a"))
-    expect(out).toContain(svg("b"))
-  })
-})
-
-describe("applyAssetIconMacro", () => {
-  test("rewrites every text entry via the resolver and returns the resolved ids", async () => {
-    const entries = [
-      { path: "/screens/home.ts", type: "text", text: `export default UIImage(assetIcon("lucide:bell"))` },
-      { path: "/shared/icon.ts", type: "text", text: `export const c = () => UIImage(assetIcon("lucide:check", { color: "#0f0" }))` },
-      { path: "/logo.png", type: "resource", text: undefined },
-    ]
-    let asked: string[] = []
-    const ids = await applyAssetIconMacro(entries, (want) => {
-      asked = want
-      return new Map(want.map((id) => [id, svg("currentColor")]))
-    })
-    expect(ids.sort()).toEqual(["lucide:bell", "lucide:check"])
-    expect(asked.sort()).toEqual(["lucide:bell", "lucide:check"])
-    expect(entries[0].text).toContain("SvgSource(`")
-    expect(entries[0].text).not.toContain("assetIcon")
-    expect(entries[1].text).toContain(`stroke="#0f0"`)
-  })
-
-  test("a no-op when nothing uses assetIcon — the resolver is never called", async () => {
-    const entries = [{ path: "/x.ts", type: "text", text: `export default UIScreen([])` }]
-    const ids = await applyAssetIconMacro(entries, () => { throw new Error("resolver must not run") })
-    expect(ids).toEqual([])
-    expect(entries[0].text).toBe(`export default UIScreen([])`)
-  })
-
-  test("a malformed call aborts before the resolver runs", async () => {
-    const entries = [{ path: "/x.ts", type: "text", text: `UIImage(assetIcon(runtimeVar))` }]
-    await expect(applyAssetIconMacro(entries, () => new Map())).rejects.toThrow(/string-literal id/)
-  })
-
-  test("an id the resolver silently omits fails the pass", async () => {
-    const entries = [{ path: "/x.ts", type: "text", text: `UIImage(assetIcon("lucide:ghost"))` }]
-    await expect(applyAssetIconMacro(entries, () => new Map())).rejects.toThrow(/could not resolve icon/)
-  })
-})
-
-describe("buildIconsHeaderValue", () => {
-  test("distinct packs, sorted", () => {
-    expect(buildIconsHeaderValue(["noto:star", "lucide:bell", "lucide:check"])).toBe("lucide;noto")
-    expect(buildIconsHeaderValue([])).toBe("")
-  })
-})
-
-describe("suggestIconNames", () => {
-  const icons = {
-    "bell": { kw: ["bell"] },
-    "bell-ring": { kw: ["bell", "ring"] },
-    "bell-off": { kw: ["bell", "off"] },
-    "check": { kw: ["check"] },
-    "arrow-right": { kw: ["arrow", "right"] },
-  }
-
-  test("a typo resolves by edit distance, exact-ish first", () => {
-    const s = suggestIconNames("bel", icons)
-    expect(s[0]).toBe("bell")
-    expect(s).toContain("bell-off") // substring family follows
-  })
-
-  test("a sub-word matches by substring", () => {
-    expect(suggestIconNames("ring", icons)).toContain("bell-ring")
-  })
-
-  test("swapped word order matches via keywords", () => {
-    expect(suggestIconNames("right-arrow", icons)).toContain("arrow-right")
-  })
-
-  test("nothing similar → empty", () => {
-    expect(suggestIconNames("zzz-qqq", icons)).toEqual([])
-  })
-})
-
-describe("iconNotFoundError", () => {
-  const registry: Record<string, string> = {
-    "lucide/meta.json": JSON.stringify({ icons: { bell: { kw: ["bell"] }, "bell-ring": { kw: ["bell", "ring"] } } }),
-    "licenses.json": JSON.stringify({ lucide: {}, tabler: {} }),
-  }
-  const read = async (rel: string) => registry[rel] ?? null
-
-  test("a known pack + missing name → did-you-mean from the pack's meta", async () => {
-    const err = await iconNotFoundError("lucide", "bel", read)
-    expect(err.message).toContain(`"lucide:bel" not found`)
-    expect(err.message).toContain(`"lucide:bell"`)
-  })
-
-  test("a known pack, nothing similar → says so", async () => {
-    const err = await iconNotFoundError("lucide", "zzz-qqq", read)
-    expect(err.message).toContain("No similar name")
-  })
-
-  test("an unknown pack → the available-pack list", async () => {
-    const err = await iconNotFoundError("nope", "bell", read)
-    expect(err.message).toContain(`unknown icon pack "nope"`)
-    expect(err.message).toContain("lucide, tabler")
-  })
-
-  test("nothing reachable → a connectivity error naming the registry", async () => {
-    const err = await iconNotFoundError("lucide", "bell", async () => null, "https://reg.example/v1")
-    expect(err.message).toContain("can't reach the icon registry (https://reg.example/v1)")
-  })
-})

package/src/compile/__tests__/assetMacro.test.ts

@@ -1,100 +0,0 @@
-import { test, expect } from "bun:test"
-import { collectAssetMacros, desugarAssetMacros } from "../assetMacro"
-import { compileProject } from "../compileProject"
-
-// A missing asset is a COMPILE ERROR — never a fallback. The old behaviour compiled
-// `asset('../x.bake')` whose file didn't exist into the source path verbatim: a string nothing
-// resolves at runtime, handed to the app as a broken reference with no diagnostic at all (and,
-// since the macro appends its generated imports, a const used before its own declaration — a TDZ
-// ReferenceError at boot that read like a bundler crash).
-
-const paths = (src: string) => collectAssetMacros(src, "/main.ts").map(r => r.path)
-
-test("a missing asset fails the compile, naming the file and the call site", async () => {
-  const main = "const scene = new Scene()\nconst bake = asset('./assets/lightmap.bake')\nconsole.log(scene, bake)\n"
-  const compile = compileProject({
-    name: "Missing",
-    publicUrl: "https://le.codes",
-    entries: [ { path: "/main.ts", type: "text", text: main } ],
-  })
-  await expect(compile).rejects.toThrow("asset not found: ./assets/lightmap.bake (main.ts:2)")
-})
-
-test("the same asset present in the entries compiles to its URL", async () => {
-  const main = "const bake = asset('./assets/lightmap.bake')\nconsole.log(bake)\n"
-  const js = await compileProject({
-    name: "Present",
-    publicUrl: "https://le.codes",
-    entries: [
-      { path: "/main.ts", type: "text", text: main },
-      { path: "/assets/lightmap.bake", type: "resource", fileSrc: "/u/lightmap.bake" },
-    ],
-  })
-  expect(js).toContain("https://le.codes/u/lightmap.bake")
-  expect(js).not.toContain("./assets/lightmap.bake")
-})
-
-// Only the modules the bundle reaches are checked: a project keeps one entry per level, and a
-// level whose art is not on this machine must not fail an entry that never imports it.
-test("a missing asset in a module the entry never imports does not fail the compile", async () => {
-  const js = await compileProject({
-    name: "Unreached",
-    publicUrl: "https://le.codes",
-    entries: [
-      { path: "/main.ts", type: "text", text: "const scene = new Scene()\nconsole.log(scene)\n" },
-      { path: "/levels/lost.ts", type: "text", text: "export const lost = asset('./lost.glb')\n" },
-    ],
-  })
-  expect(js).not.toContain("lost.glb")
-})
-
-test("the same missing asset fails once the entry imports its module", async () => {
-  const compile = compileProject({
-    name: "Reached",
-    publicUrl: "https://le.codes",
-    entries: [
-      { path: "/main.ts", type: "text", text: "import { lost } from './levels/lost'\nconsole.log(lost)\n" },
-      { path: "/levels/lost.ts", type: "text", text: "export const lost = asset('./lost.glb')\n" },
-    ],
-  })
-  await expect(compile).rejects.toThrow("asset not found: ./lost.glb (levels/lost.ts:1)")
-})
-
-test("a commented-out asset() is not an asset at all", () => {
-  const src = [
-    "/** The atlas image — write `asset('./TileSet.png')`. */",
-    "// const old = asset('./deleted.png')",
-    "const live = asset('./hero.png')",
-    "/* asset('./block-commented.png') */",
-  ].join("\n")
-  expect(paths(src)).toEqual([ "./hero.png" ])
-  const out = desugarAssetMacros(src, "/main.ts")
-  expect(out).toContain(`import __asset_0 from "./hero.png";`)
-  expect(out).not.toContain("deleted.png\";")
-  expect(out).toContain("asset('./deleted.png')") // the comment itself is untouched
-})
-
-test("an asset() inside a string literal is text, one inside `${…}` is a call", () => {
-  expect(paths(`const doc = "call asset('./x.png') to load"`)).toEqual([])
-  expect(paths("const url = `bg:${asset('./bg.png')}`")).toEqual([ "./bg.png" ])
-  expect(paths("const url = `not ${1} asset('./no.png')`")).toEqual([])
-})
-
-test("method calls named asset are still untouched, dynamic arguments still throw", () => {
-  expect(paths(`state.model = ui.asset("model")`)).toEqual([])
-  expect(() => paths("const p = './x.png'\nconst a = asset(p)")).toThrow("expects a string literal")
-})
-
-test("repeated paths share one import and the line numbers stay exact", () => {
-  const src = "const a = asset('./x.png')\n\nconst b = asset('./x.png')\nconst c = asset('./y.png')\n"
-  const refs = collectAssetMacros(src, "/main.ts")
-  expect(refs.map(r => r.line)).toEqual([ 1, 3, 4 ])
-  const out = desugarAssetMacros(src, "/main.ts")
-  // The generated imports are APPENDED, so no original line moves (source maps stay honest).
-  const lines = out.split("\n")
-  expect(lines.slice(0, 4)).toEqual([ "const a = __asset_0", "", "const b = __asset_0", "const c = __asset_1" ])
-  expect(lines.slice(4).join("\n")).toContain("import __asset_0")
-  expect(out).toContain("const a = __asset_0")
-  expect(out).toContain("const b = __asset_0")
-  expect(out).toContain("const c = __asset_1")
-})

package/src/compile/__tests__/assetName.test.ts

@@ -1,55 +0,0 @@
-import { test, expect } from "bun:test"
-import { isCanonicalAssetName, sanitizeAssetName } from "../assetName"
-
-// The invariant: two names that LOOK the same on screen must be stored the same way, or the import
-// written from what the user sees resolves to nothing. Codepoints are spelled out via fromCharCode
-// so the cases stay readable — the characters themselves are invisible in an editor.
-
-const NBSP = String.fromCharCode(0x00a0)
-const NARROW_NBSP = String.fromCharCode(0x202f)
-const ZERO_WIDTH = String.fromCharCode(0x200b)
-const RTL_MARK = String.fromCharCode(0x200f)
-const COMBINING_BREVE = String.fromCharCode(0x0306)
-
-test("a non-breaking space becomes the plain space the user types in an import", () => {
-  expect(sanitizeAssetName(`итальянский${NBSP}сквер1.jpg`)).toBe("итальянский сквер1.jpg")
-  expect(sanitizeAssetName(`narrow${NARROW_NBSP}space.png`)).toBe("narrow space.png")
-})
-
-test("a decomposed name (what macOS hands out) composes to the same codepoints as typed text", () => {
-  // "й" as и + combining breve — indistinguishable on screen from the single U+0439 codepoint.
-  const decomposed = `и${COMBINING_BREVE}ога.glb`
-  expect(decomposed).not.toBe("йога.glb")
-  expect(sanitizeAssetName(decomposed)).toBe("йога.glb")
-})
-
-test("zero-width and bidi characters are dropped", () => {
-  expect(sanitizeAssetName(`logo${ZERO_WIDTH}.png`)).toBe("logo.png")
-  expect(sanitizeAssetName(`${RTL_MARK}logo.png`)).toBe("logo.png")
-})
-
-test("path separators and Windows-illegal characters can't enter a name", () => {
-  expect(sanitizeAssetName("a/b.png")).toBe("a_b.png")
-  expect(sanitizeAssetName("a\\b.png")).toBe("a_b.png")
-  expect(sanitizeAssetName('q?:*"<>|.png')).toBe("q_______.png")
-})
-
-test("surrounding whitespace and trailing dots go; a leading dot stays", () => {
-  expect(sanitizeAssetName("  main.ts ")).toBe("main.ts")
-  expect(sanitizeAssetName("main.ts...")).toBe("main.ts")
-  expect(sanitizeAssetName(".gitignore")).toBe(".gitignore")
-  expect(sanitizeAssetName("two  spaces.png")).toBe("two spaces.png")
-})
-
-test("an ordinary name is returned untouched and sanitizing is idempotent", () => {
-  for (const name of [ "main.ts", "итальянский сквер1.jpg", "My Scene.scene", "ui-kit.mat" ]) {
-    expect(sanitizeAssetName(name)).toBe(name)
-    expect(isCanonicalAssetName(name)).toBe(true)
-    expect(sanitizeAssetName(sanitizeAssetName(name))).toBe(sanitizeAssetName(name))
-  }
-})
-
-test("a name with nothing printable left comes back empty (callers reject it)", () => {
-  expect(sanitizeAssetName(`  ${ZERO_WIDTH}${NBSP} `)).toBe("")
-  expect(isCanonicalAssetName(`x${ZERO_WIDTH}.png`)).toBe(false)
-})