uxml-preview 0.2.0 → 0.4.0

package/dist/known-divergences.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Differences from Unity that measurement has confirmed and that fixing the
+ * renderer cannot close. `docs/accuracy.md` describes 16 divergent values;
+ * all but one class of them are listed below.
+ *
+ * The 1px cases (3 values) are excluded on purpose: they sit inside the
+ * golden tests' own 0.5px-tighter-than-plan tolerance. That is a test
+ * judgement parameter, not a rendering limitation — listing it here would
+ * tell a host to worry about a difference the renderer did not actually make.
+ *
+ * If a fourth category is ever promoted here, extend this list and the
+ * pinned entry count in tests/known-divergences.test.ts together — do not
+ * let the list grow silently, since `id` is a contract hosts key off.
+ */
+export interface KnownDivergence {
+    /** Stable identifier. Hosts may key off this; do not rename. */
+    readonly id: string;
+    /**
+     * Why this cannot simply be fixed.
+     *
+     * 'unreproducible' — the difference comes from something we cannot
+     *   reproduce at all, such as font metrics that move with the platform.
+     * 'unspecified'    — Unity's own rule for this case is not specified,
+     *   so there is no target to match yet.
+     * 'upstream'       — the difference is fully reproducible and deterministic,
+     *   but it lives in something this renderer depends on rather than in this
+     *   renderer's own code — the place that would need to change is not this
+     *   repository.
+     */
+    readonly kind: 'unreproducible' | 'unspecified' | 'upstream';
+    /** One line, for a diagnostics list. */
+    readonly summary: string;
+    /** What is different and why, for someone deciding whether to care. */
+    readonly detail: string;
+}
+export declare const KNOWN_DIVERGENCES: readonly KnownDivergence[];

package/dist/model/types.d.ts

@@ -196,6 +196,7 @@ export type SheetItem = {
     kind: 'import';
     url: string;
     span: Span;
+    resolvedSheet?: number;
 } | {
     kind: 'unknown';
     span: Span;
@@ -244,7 +245,17 @@ export interface UxmlDocument {
      * own `source`, which is why the source text lives on the sheet.
      */
     sheets: StyleSheet[];
-    /** Parse-time only — malformed input. Support judgments happen downstream. */
+    /** Stylesheet entry points and the element subtree each one is attached to. */
+    styleRoots?: Array<{
+        sheet: number;
+        scope: NodeId;
+    }>;
+    /**
+     * Parse-time only — `'malformed'` (bad syntax) and `'import-unresolved'`
+     * (a `<Style src="…">` or `@import` that `resolveImport` could not read).
+     * Support judgments (unsupported controls/properties/selectors/units,
+     * unresolved assets) happen downstream, in `RenderResult.warnings`.
+     */
     warnings: Warning[];
 }
 /**

package/dist/render/css-map.d.ts

@@ -1,7 +1,16 @@
 import { NodeId, Warning } from '../model/types';
 import { ComputedStyle } from '../style/resolve';
 export interface CssMapOptions {
-    resolveAsset?: ((path: string) => string | null) | undefined;
+    /**
+     * `form` tells `url("...")` apart from `resource("...")` — Unity resolves
+     * them differently: `url()` is a path (relative to the project or
+     * absolute), `resource()` names an asset inside a Resources folder by its
+     * Unity resource path (no extension). A host that ignores `form` and
+     * treats every path the same will resolve `resource("foo")` as a literal
+     * file path, which silently draws the wrong image whenever a same-named
+     * file happens to sit alongside it — or resolves nothing at all.
+     */
+    resolveAsset?: ((path: string, form: 'url' | 'resource') => string | null) | undefined;
 }
 export interface CssMapResult {
     declarations: Record<string, string>;

package/dist/unity-project/index.d.ts

@@ -0,0 +1,14 @@
+export interface GuidIndex {
+    /** Absolute path of the asset with this GUID, or null. */
+    get(guid: string): string | null;
+    /** Number of entries. Lets a host report an empty scan. */
+    readonly size: number;
+}
+/**
+ * Purpose: resolve a `project://database/Assets/...` reference whose file has
+ * moved, by walking `.meta` files for their `guid:` line instead.
+ * Deps/Effects: reads the directory tree under `projectRoot`; unreadable
+ * `.meta` files are skipped rather than thrown, so one bad file cannot fail
+ * the whole scan.
+ */
+export declare function buildGuidIndex(projectRoot: string): Promise<GuidIndex>;

package/dist/unity-project/index.js

@@ -0,0 +1,41 @@
+import { readdir as c, readFile as u } from "node:fs/promises";
+import { join as s } from "node:path";
+const l = /* @__PURE__ */ new Set(["Library", "Temp", "obj", ".git"]), f = /^guid:\s*([0-9a-fA-F]+)/m;
+async function y(n) {
+  const t = /* @__PURE__ */ new Map();
+  return await o(n, t), {
+    get(e) {
+      return t.get(e) ?? null;
+    },
+    get size() {
+      return t.size;
+    }
+  };
+}
+async function o(n, t) {
+  const e = await c(n, { withFileTypes: !0 });
+  for (const i of e) {
+    const a = s(n, i.name);
+    if (i.isDirectory()) {
+      if (l.has(i.name)) continue;
+      await o(a, t);
+      continue;
+    }
+    if (!i.name.endsWith(".meta")) continue;
+    const r = await m(a);
+    r !== null && t.set(r, a.slice(0, -5));
+  }
+}
+async function m(n) {
+  var e;
+  let t;
+  try {
+    t = await u(n, "utf8");
+  } catch {
+    return null;
+  }
+  return ((e = f.exec(t)) == null ? void 0 : e[1]) ?? null;
+}
+export {
+  y as buildGuidIndex
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "uxml-preview",
-  "version": "0.2.0",
-  "description": "Preview Unity UI Toolkit UXML/USS in a browser without the Unity Editor. Uses Yoga (WebAssembly), the same layout engine UI Toolkit uses: 242 of 244 element coordinates identical to Unity 6. Parses and writes files back byte-for-byte.",
+  "version": "0.4.0",
+  "description": "Preview Unity UI Toolkit UXML/USS in a browser without the Unity Editor. Uses Yoga (WebAssembly), the same layout engine UI Toolkit uses: 660 of 676 element coordinates identical to Unity 6. Parses and writes files back byte-for-byte.",
   "keywords": [
     "unity",
     "unity3d",
@@ -31,6 +31,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./unity-project": {
+      "types": "./dist/unity-project/index.d.ts",
+      "import": "./dist/unity-project/index.js"
     }
   },
   "files": [