@absolutejs/absolute 0.19.0-beta.924 → 0.19.0-beta.926

package/dist/index.js

@@ -17789,6 +17789,7 @@ var init_rewriteImports = __esm(() => {
 var exports_resolveOwningComponents = {};
 __export(exports_resolveOwningComponents, {
   resolveOwningComponents: () => resolveOwningComponents,
+  resolveDescendantsOfParent: () => resolveDescendantsOfParent,
   invalidateResourceIndex: () => invalidateResourceIndex
 });
 import { readdirSync as readdirSync2, readFileSync as readFileSync19, statSync as statSync3 } from "fs";
@@ -17869,11 +17870,23 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
         const kind = ENTITY_DECORATORS[fn2.text];
         if (!kind)
           continue;
+        let extendsName = null;
+        for (const heritage of node.heritageClauses ?? []) {
+          if (heritage.token !== ts3.SyntaxKind.ExtendsKeyword) {
+            continue;
+          }
+          const first = heritage.types[0];
+          if (first && ts3.isIdentifier(first.expression)) {
+            extendsName = first.expression.text;
+          }
+          break;
+        }
         const entry = {
           className: node.name.text,
           kind,
           styleUrls: [],
-          templateUrls: []
+          templateUrls: [],
+          extendsName
         };
         const arg = expr.arguments[0];
         if (arg && ts3.isObjectLiteralExpression(arg) && kind === "component") {
@@ -17926,36 +17939,117 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
     out.push(...owners);
   }
   return out;
-}, resourceIndexByRoot, getOrBuildResourceIndex = (userAngularRoot) => {
-  const cached = resourceIndexByRoot.get(userAngularRoot);
+}, indexByRoot, resolveParentClassFile = (parentName, childFilePath, angularRoot) => {
+  let source;
+  try {
+    source = readFileSync19(childFilePath, "utf8");
+  } catch {
+    return null;
+  }
+  const sf = ts3.createSourceFile(childFilePath, source, ts3.ScriptTarget.ES2022, true, ts3.ScriptKind.TS);
+  const childDir = dirname18(childFilePath);
+  for (const stmt of sf.statements) {
+    if (!ts3.isImportDeclaration(stmt))
+      continue;
+    if (!ts3.isStringLiteral(stmt.moduleSpecifier))
+      continue;
+    const clause = stmt.importClause;
+    if (!clause || clause.isTypeOnly)
+      continue;
+    let matchesName = false;
+    if (clause.name && clause.name.text === parentName)
+      matchesName = true;
+    if (!matchesName && clause.namedBindings && ts3.isNamedImports(clause.namedBindings)) {
+      for (const el of clause.namedBindings.elements) {
+        if (el.isTypeOnly)
+          continue;
+        if (el.name.text === parentName) {
+          matchesName = true;
+          break;
+        }
+      }
+    }
+    if (!matchesName)
+      continue;
+    const spec = stmt.moduleSpecifier.text;
+    if (!spec.startsWith(".") && !spec.startsWith("/")) {
+      return null;
+    }
+    const base = resolve33(childDir, spec);
+    const candidates = [
+      `${base}.ts`,
+      `${base}.tsx`,
+      `${base}/index.ts`,
+      `${base}/index.tsx`
+    ];
+    const angularRootNorm = safeNormalize(angularRoot);
+    for (const candidate of candidates) {
+      try {
+        if (statSync3(candidate).isFile()) {
+          const norm = safeNormalize(candidate);
+          if (!norm.startsWith(angularRootNorm))
+            return null;
+          return norm;
+        }
+      } catch {}
+    }
+    return null;
+  }
+  return null;
+}, getOrBuildIndexes = (userAngularRoot) => {
+  const cached = indexByRoot.get(userAngularRoot);
   if (cached)
     return cached;
-  const index = new Map;
+  const resource = new Map;
+  const parentFile = new Map;
   for (const tsPath of walkAngularSourceFiles(userAngularRoot)) {
     const classes = parseDecoratedClasses(tsPath);
     const componentDir = dirname18(tsPath);
     for (const cls of classes) {
-      if (cls.kind !== "component")
-        continue;
-      const owner = {
+      const entity = {
         className: cls.className,
         componentFilePath: tsPath,
-        kind: "component"
+        kind: cls.kind
       };
-      for (const url of [...cls.templateUrls, ...cls.styleUrls]) {
-        const abs = safeNormalize(resolve33(componentDir, url));
-        const existing = index.get(abs);
-        if (existing)
-          existing.push(owner);
-        else
-          index.set(abs, [owner]);
+      if (cls.kind === "component") {
+        for (const url of [...cls.templateUrls, ...cls.styleUrls]) {
+          const abs = safeNormalize(resolve33(componentDir, url));
+          const existing = resource.get(abs);
+          if (existing)
+            existing.push(entity);
+          else
+            resource.set(abs, [entity]);
+        }
+      }
+      if (cls.extendsName !== null) {
+        const parentPath = resolveParentClassFile(cls.extendsName, tsPath, userAngularRoot);
+        if (parentPath !== null && parentPath !== safeNormalize(tsPath)) {
+          const existing = parentFile.get(parentPath);
+          if (existing)
+            existing.push(entity);
+          else
+            parentFile.set(parentPath, [entity]);
+        }
       }
     }
   }
-  resourceIndexByRoot.set(userAngularRoot, index);
-  return index;
+  const bundle = { parentFile, resource };
+  indexByRoot.set(userAngularRoot, bundle);
+  return bundle;
+}, getOrBuildResourceIndex = (userAngularRoot) => getOrBuildIndexes(userAngularRoot).resource, resolveDescendantsOfParent = (params) => {
+  const norm = safeNormalize(params.changedFilePath);
+  let rootStat;
+  try {
+    rootStat = statSync3(params.userAngularRoot);
+  } catch {
+    return [];
+  }
+  if (!rootStat.isDirectory())
+    return [];
+  const bundle = getOrBuildIndexes(params.userAngularRoot);
+  return bundle.parentFile.get(norm) ?? [];
 }, invalidateResourceIndex = () => {
-  resourceIndexByRoot.clear();
+  indexByRoot.clear();
 };
 var init_resolveOwningComponents = __esm(() => {
   ENTITY_DECORATORS = {
@@ -17964,7 +18058,7 @@ var init_resolveOwningComponents = __esm(() => {
     Pipe: "pipe",
     Injectable: "service"
   };
-  resourceIndexByRoot = new Map;
+  indexByRoot = new Map;
 });
 
 // src/dev/angular/hmrImportGenerator.ts
@@ -18702,6 +18796,74 @@ var fail = (reason, detail, location) => ({
   fingerprintCache.set(id, fp);
 }, invalidateFingerprintCache = () => {
   fingerprintCache.clear();
+  entityFingerprintCache.clear();
+}, entityFingerprintCache, entityFingerprintsEqual = (a, b2) => {
+  if (a.className !== b2.className)
+    return false;
+  if (a.decoratorArgsText !== b2.decoratorArgsText)
+    return false;
+  if (!arraysEqual(a.ctorParamTypes, b2.ctorParamTypes))
+    return false;
+  if (!arraysEqual(a.topLevelImports, b2.topLevelImports))
+    return false;
+  if (!arraysEqual(a.memberDecoratorSig, b2.memberDecoratorSig))
+    return false;
+  if (!arraysEqual(a.arrowFieldSig, b2.arrowFieldSig))
+    return false;
+  if (!arraysEqual(a.propertyFieldNames, b2.propertyFieldNames))
+    return false;
+  return true;
+}, ENTITY_DECORATOR_NAMES, findEntityDecorator = (cls) => {
+  for (const dec of ts7.getDecorators(cls) ?? []) {
+    const expr = dec.expression;
+    if (!ts7.isCallExpression(expr))
+      continue;
+    if (!ts7.isIdentifier(expr.expression))
+      continue;
+    if (ENTITY_DECORATOR_NAMES.has(expr.expression.text))
+      return dec;
+  }
+  return null;
+}, extractEntityFingerprint = (cls, className, sourceFile) => {
+  const decorator = findEntityDecorator(cls);
+  let decoratorArgsText = "";
+  if (decorator !== null) {
+    const expr = decorator.expression;
+    const arg = expr.arguments[0];
+    if (arg !== undefined) {
+      decoratorArgsText = arg.getText().replace(/\s+/g, " ").trim();
+    }
+  }
+  const ctorParamTypes = [];
+  for (const member of cls.members) {
+    if (!ts7.isConstructorDeclaration(member))
+      continue;
+    for (const param of member.parameters) {
+      const typeText = param.type ? param.type.getText() : "";
+      const decorators = ts7.getDecorators(param) ?? [];
+      const decoratorSig = decorators.length === 0 ? "" : decorators.map((d2) => {
+        const e = d2.expression;
+        if (ts7.isCallExpression(e) && ts7.isIdentifier(e.expression)) {
+          const args = e.arguments.map((a) => a.getText()).join(",");
+          return `@${e.expression.text}(${args})`;
+        }
+        if (ts7.isIdentifier(e))
+          return `@${e.text}`;
+        return "@<unknown>";
+      }).join("");
+      ctorParamTypes.push(`${typeText}${decoratorSig}`);
+    }
+    break;
+  }
+  return {
+    className,
+    decoratorArgsText,
+    ctorParamTypes,
+    topLevelImports: extractTopLevelImports(sourceFile),
+    memberDecoratorSig: extractMemberDecoratorSig(cls),
+    arrowFieldSig: extractArrowFieldSig(cls),
+    propertyFieldNames: extractPropertyFieldNames(cls)
+  };
 }, findClassDeclaration = (sourceFile, className) => {
   let found = null;
   const walk = (node) => {
@@ -18839,6 +19001,33 @@ var fail = (reason, detail, location) => ({
     }
   }
   return false;
+}, CONTROL_CREATE_METHOD_NAME = "\u0275ngControlCreate", extractControlCreate = (cls) => {
+  for (const member of cls.members) {
+    if (!ts7.isMethodDeclaration(member))
+      continue;
+    if (member.modifiers?.some((m) => m.kind === ts7.SyntaxKind.StaticKeyword))
+      continue;
+    const name = member.name;
+    if (name === undefined)
+      continue;
+    const nameText = ts7.isIdentifier(name) ? name.text : name.getText();
+    if (nameText !== CONTROL_CREATE_METHOD_NAME)
+      continue;
+    const firstParam = member.parameters[0];
+    if (firstParam === undefined || firstParam.type === undefined || !ts7.isTypeReferenceNode(firstParam.type)) {
+      return { passThroughInput: null };
+    }
+    const typeArgs = firstParam.type.typeArguments;
+    if (typeArgs === undefined || typeArgs.length !== 1) {
+      return { passThroughInput: null };
+    }
+    const arg = typeArgs[0];
+    if (arg === undefined || !ts7.isLiteralTypeNode(arg) || !ts7.isStringLiteral(arg.literal)) {
+      return { passThroughInput: null };
+    }
+    return { passThroughInput: arg.literal.text };
+  }
+  return null;
 }, resolveEnumPropertyAccess = (expr, enumName, values) => {
   if (!ts7.isPropertyAccessExpression(expr))
     return null;
@@ -20018,10 +20207,17 @@ ${block}
   }
   const kind = params.kind ?? "component";
   if (kind !== "component") {
+    const entityId = encodeURIComponent(`${relative13(projectRoot, componentFilePath).replace(/\\/g, "/")}@${className}`);
+    const currentEntityFingerprint = extractEntityFingerprint(classNode, className, sourceFile);
+    const cachedEntityFingerprint = entityFingerprintCache.get(entityId);
+    if (cachedEntityFingerprint !== undefined && !entityFingerprintsEqual(cachedEntityFingerprint, currentEntityFingerprint)) {
+      return fail("structural-change", `${kind} ${className} decorator-args or structural surface changed`);
+    }
     const moduleText = buildSimpleEntityModule(classNode, className);
     if (!moduleText) {
       return fail("unexpected-error", `buildSimpleEntityModule returned null for ${className}`);
     }
+    entityFingerprintCache.set(entityId, currentEntityFingerprint);
     return {
       componentSource: sourceFile,
       fingerprintChanged: false,
@@ -20132,7 +20328,7 @@ ${block}
     inputs,
     outputs,
     usesInheritance: false,
-    controlCreate: null,
+    controlCreate: extractControlCreate(classNode),
     exportAs: advancedMetadata.exportAs,
     providers: advancedMetadata.providers,
     isStandalone: decoratorMeta.standalone,
@@ -20301,6 +20497,12 @@ var init_fastHmrCompiler = __esm(() => {
   init_typescript_translator();
   fingerprintCache = new Map;
   pendingModuleCache = new Map;
+  entityFingerprintCache = new Map;
+  ENTITY_DECORATOR_NAMES = new Set([
+    "Pipe",
+    "Directive",
+    "Injectable"
+  ]);
   VIEW_ENCAPSULATION_VALUES = {
     Emulated: 0,
     ExperimentalIsolatedShadowDom: 4,
@@ -20999,6 +21201,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   let anyFingerprintChanged = false;
   let totalResolveMs = 0;
   let totalCompileMs = 0;
+  const { resolveDescendantsOfParent: resolveDescendantsOfParent2 } = await Promise.resolve().then(() => (init_resolveOwningComponents(), exports_resolveOwningComponents));
   for (const editedFile of userEdited) {
     const resolveStart = performance.now();
     const owners = resolveOwningComponents2({
@@ -21006,6 +21209,20 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
       userAngularRoot: angularDir
     });
     totalResolveMs += performance.now() - resolveStart;
+    if (owners.length === 0) {
+      const descendants = resolveDescendantsOfParent2({
+        changedFilePath: editedFile,
+        userAngularRoot: angularDir
+      });
+      if (descendants.length > 0) {
+        const names = descendants.map((d2) => d2.className).slice(0, 3).join(", ");
+        return {
+          kind: "rebootstrap",
+          reason: `parent class file edited; descendant Angular entities (${names}${descendants.length > 3 ? ", ..." : ""}) need to pick up new prototype`,
+          tier: 1
+        };
+      }
+    }
     if (owners.length === 0 && (editedFile.endsWith(".component.ts") || editedFile.endsWith(".directive.ts") || editedFile.endsWith(".pipe.ts") || editedFile.endsWith(".service.ts"))) {
       return {
         kind: "rebootstrap",
@@ -31594,5 +31811,5 @@ export {
   ANGULAR_INIT_TIMEOUT_MS
 };
 
-//# debugId=F92C1416B50F9B9A64756E2164756E21
+//# debugId=26FFFD73925522E664756E2164756E21
 //# sourceMappingURL=index.js.map