@volter/editor-react 0.5.211 → 0.5.212

package/src/source/component-prop-types.ts

@@ -1,44 +1,8 @@
-/**
- * Declared-prop resolution for a custom R3F component — what the inspector
- * shows for a `<Enemy …>` node.
- *
- * WHY THIS EXISTS. The inspector used to describe a node purely by the
- * attributes physically written in its JSX tag: a prop nobody typed was
- * invisible, and its widget was guessed from the raw attribute text, so
- * `variant="sharpshooter"` read as free text even though the component
- * declares a two-value union. That is backwards from every mainstream engine —
- * Unity/Godot/Unreal show a component's whole declared surface at its defaults
- * and treat the authored values as the subset you have overridden.
- *
- * HOW IT PARSES, and why not the way the neighbours do. Two different
- * questions need two different tools:
- *
- *   - WHICH props belong to this component is SYNTACTIC. It is the members the
- *     author literally wrote in the props type. `ThreeElements['group'] & {…}`
- *     contributes only the `{…}`; the forwarded native surface is hundreds of
- *     three.js props the author did not author. So this walks the type node's
- *     own AST and only descends into declarations that live in the project.
- *
- *   - WHAT TYPE each prop has is SEMANTIC, and is exactly the job of the
- *     TypeScript type checker. `variant: EnemyVariant` where
- *     `EnemyVariant = keyof typeof ENEMY_MODEL_PATHS` resolves to
- *     `'raider' | 'sharpshooter'` with no grammar written here at all.
- *
- * The sibling analysers in `oid-transform.ts` answer their (narrower) type
- * question by regexing `TypeNode.getText()`, which is why they only recognize
- * `ThreeElements['group']` spelled that one way. Do not copy that here: a
- * checker was always the right instrument for reading types, and this module
- * pays the one-time cost of a real program to get it.
- *
- * COST. A `ts.LanguageService` over the project's own tsconfig — ~1.7s and
- * ~2.4k files cold for a shipped example, then warm and incremental. It is
- * built lazily on the first inspector query and reused; only project files are
- * version-stamped, so an ordinary edit re-checks without a rebuild.
- *
- * SERVER-SIDE ONLY: this imports `typescript` and `node:fs` and is used from
- * `vite-plugin-ui-oid.ts`. The editor bundle receives the RESULT on the OID
- * index entry — it never parses TypeScript itself.
- */
+/** Resolve authored component props with the project's TypeScript language service.
+ * The authored prop names come from project type declarations; the checker
+ * supplies their types, including aliases and inferred union values. Native
+ * forwarded props are excluded. The service is lazy and incremental, and runs
+ * in the declared-prop worker; clients receive the resulting OID-index specs. */
 import { statSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import ts from 'typescript';
@@ -467,27 +431,7 @@ export class ComponentPropResolver {
     for (const { symbol, declaration } of ownProps(propsType, homePackage)) {
       specs.set(symbol.getName(), declaredSpec(symbol, declaration, checker, defaults));
     }
-    // A prop the component DESTRUCTURES is a prop it reads, whatever package
-    // its type was declared in — so membership is settled and only the type is
-    // left, which is the checker's job (this module's own split, see the
-    // header). `ownProps`' package filter answers "which of the hundreds of
-    // FORWARDED members did this author write?"; it must not also decide
-    // whether a prop the author literally named has a knowable type.
-    //
-    // MEASURED on the racing ingest: `<Physics allowSleep broadphase
-    // defaultContactMaterial>` and `<Vehicle angularVelocity>` are all read by
-    // their component's own destructuring while being declared in
-    // `@pmndrs/cannon-worker-api` — a different package from the component's
-    // — so every one arrived typeless and the inspector fell through to
-    // guessing the widget from the attribute TEXT (`allowSleep` → `boolean` by
-    // luck; `broadphase` → free-text `string` where the declaration is a
-    // two-value union; `angularVelocity` → `string` where it is a Triplet).
-    //
-    // `getTypeOfSymbol`, not `getTypeOfSymbolAtLocation`: a `Pick<>`-mapped
-    // member has NO declaration to pass as the location (measured — `Vehicle`'s
-    // `angularVelocity` reports `declarations.length === 0`), which is also why
-    // `declaredSpec` cannot be reused here. A prop with no reachable type stays
-    // `null`, and the inspector's loud text-guess fallback still covers it.
+    // Resolve aliased type members through their symbol at the JSX opening element.
     for (const name of order) {
       if (specs.has(name)) continue;
       const symbol = propsType.getProperty(name);

package/src/source/drei-detailed-names.ts

@@ -0,0 +1,24 @@
+/** Local JSX names imported as Drei's Detailed component. */
+
+import ts from 'typescript';
+
+export function dreiDetailedLocalNames(sf: ts.SourceFile): Set<string> {
+  const names = new Set<string>();
+  for (const statement of sf.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) {
+      continue;
+    }
+    if (!statement.moduleSpecifier.text.startsWith('@react-three/drei')) continue;
+    const bindings = statement.importClause?.namedBindings;
+    if (bindings && ts.isNamedImports(bindings)) {
+      for (const element of bindings.elements) {
+        if ((element.propertyName?.text ?? element.name.text) === 'Detailed') {
+          names.add(element.name.text);
+        }
+      }
+    } else if (bindings && ts.isNamespaceImport(bindings)) {
+      names.add(`${bindings.name.text}.Detailed`);
+    }
+  }
+  return names;
+}