@fulcro/transform-core 0.3.0 → 0.4.0

package/dist/index.d.ts

@@ -17,5 +17,5 @@
  * other.
  */
 export { createFileTransformer, type FileTransformer, type TransformCoreOptions, } from './program/index.js';
-export { type CallRewriter, IDENTIFIER_PATTERN, isOwnedCall, isTupleType, type RewriteContext, utilityModuleSegment, } from './shared/index.js';
+export { type CallForm, type CallRewriter, IDENTIFIER_PATTERN, isOwnedCall, isTupleType, type RewriteContext, utilityModuleSegment, } from './shared/index.js';
 export { createTransformer, type TransformerFactory, type TransformerOptions, } from './transformer/index.js';

package/dist/shared/index.d.ts

@@ -24,12 +24,30 @@ export interface RewriteContext {
      */
     readonly visit: (node: typescript.Node) => typescript.Node;
 }
+/**
+ * How a rewritten call is written at the call site.
+ *
+ * A free function is reached through an identifier the consumer imported; a
+ * method is reached through whatever expression it is called on, so there is no
+ * import to follow and the receiver could be anything. Both are resolved the
+ * same way in the end — by following the symbol back to its declaration — but
+ * the node to ask about differs.
+ */
+export type CallForm = 'function' | 'method';
 /** Rewrites the calls of a single utility. */
 export interface CallRewriter {
     /** Name the exported function is called by. */
     readonly functionName: string;
     /** Path segment identifying the module that declares it. */
     readonly moduleSegment: string;
+    /**
+     * Shape of the call, defaulting to a free function.
+     *
+     * `'method'` claims `something.name(…)` rather than `name(…)`, which is what
+     * lets a library rewrite calls on its own types — `sequence.ofType<T>()` —
+     * where nothing was imported by that name.
+     */
+    readonly callForm?: CallForm;
     /**
      * Rewrites one call.
      *

package/dist/shared/index.js

@@ -72,11 +72,24 @@ exports.utilityModuleSegment = utilityModuleSegment;
  * @returns `true` when the call targets the function of that rewriter.
  */
 const isOwnedCall = (call, checker, rewriter) => {
-    if (!typescript_1.default.isIdentifier(call.expression))
+    // The node carrying the name differs between the two forms: an identifier
+    // standing on its own, or the member half of a property access. Everything
+    // after this point is the same question asked of that node.
+    // `MemberName` rather than `Identifier`: a property access can also name a
+    // private member, which carries a `text` like any other and simply never
+    // matches one of ours.
+    const named = rewriter.callForm === 'method'
+        ? typescript_1.default.isPropertyAccessExpression(call.expression)
+            ? call.expression.name
+            : null
+        : typescript_1.default.isIdentifier(call.expression)
+            ? call.expression
+            : null;
+    if (named === null)
         return false;
-    if (call.expression.text !== rewriter.functionName)
+    if (named.text !== rewriter.functionName)
         return false;
-    const symbol = checker.getSymbolAtLocation(call.expression);
+    const symbol = checker.getSymbolAtLocation(named);
     const resolved = symbol !== undefined && (symbol.flags & typescript_1.default.SymbolFlags.Alias) !== 0
         ? checker.getAliasedSymbol(symbol)
         : symbol;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@fulcro/transform-core",
-	"version": "0.3.0",
+	"version": "0.4.0",
 	"description": "Shared machinery behind the Fulcro compile time transformers. Installed for you; not meant to be depended on directly.",
 	"keywords": [
 		"typescript",