@lowgular/code-graph 0.0.1

package/libs/cli/code-graph/src/lib/core.js

@@ -0,0 +1,85 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var core_exports = {};
+__export(core_exports, {
+  extractArgumentNames: () => extractArgumentNames,
+  extractMethodName: () => extractMethodName,
+  extractTargetName: () => extractTargetName,
+  generateFileRootNodeId: () => generateFileRootNodeId,
+  generateIdByRange: () => generateIdByRange,
+  mergeCodeGraphs: () => mergeCodeGraphs
+});
+module.exports = __toCommonJS(core_exports);
+const ts = require("typescript");
+const extractTargetName = (snippet) => {
+  const thisMatch = snippet.match(/this\.([a-zA-Z_$][a-zA-Z0-9_$]*)\./);
+  if (thisMatch) {
+    return thisMatch[1];
+  }
+  return null;
+};
+const extractMethodName = (snippet) => {
+  const methodMatch = snippet.match(/\.([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/);
+  if (methodMatch) {
+    return methodMatch[1];
+  }
+  return null;
+};
+const extractArgumentNames = (snippet) => {
+  const lastOpenParen = snippet.lastIndexOf("(");
+  if (lastOpenParen === -1) {
+    return [];
+  }
+  const afterParen = snippet.substring(lastOpenParen + 1);
+  const closeParen = afterParen.indexOf(")");
+  if (closeParen === -1) {
+    return [];
+  }
+  const argsString = afterParen.substring(0, closeParen).trim();
+  if (!argsString) {
+    return [];
+  }
+  return argsString.split(",").map((arg) => arg.trim()).map((arg) => {
+    const identifierMatch = arg.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)/);
+    return identifierMatch ? identifierMatch[1] : null;
+  }).filter((name) => name !== null);
+};
+const generateIdByRange = (prefix, node) => {
+  const range = node.range;
+  return `${prefix}.s${range.start.line}-${range.start.character}e${range.end.line}-${range.end.character}`;
+};
+const mergeCodeGraphs = (codeGraph, classGraph) => {
+  Object.assign(codeGraph.nodesById, classGraph.nodesById);
+  Object.values(classGraph.edgesBySource).flat().forEach((edge) => {
+    if (!codeGraph.edgesBySource[edge.source]) {
+      codeGraph.edgesBySource[edge.source] = [];
+    }
+  });
+};
+const generateFileRootNodeId = (node) => {
+  return node.filePath + "@" + node.name;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractArgumentNames,
+  extractMethodName,
+  extractTargetName,
+  generateFileRootNodeId,
+  generateIdByRange,
+  mergeCodeGraphs
+});

package/libs/cli/code-graph/src/lib/decorators/index.js

@@ -0,0 +1,36 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var decorators_exports = {};
+__export(decorators_exports, {
+  DECORATOR_DOC: () => DECORATOR_DOC
+});
+module.exports = __toCommonJS(decorators_exports);
+const DECORATOR_DOC = {
+  id: "decorator",
+  name: "Decorator",
+  schema: {
+    name: "string"
+  },
+  relationships: {},
+  description: `The node represents TypeScript AST kind: Decorator.`,
+  examples: []
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DECORATOR_DOC
+});

package/libs/cli/code-graph/src/lib/docs/index.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var docs_exports = {};
+module.exports = __toCommonJS(docs_exports);
+__reExport(docs_exports, require("./specs"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./specs")
+});

package/libs/cli/code-graph/src/lib/docs/specs.js

@@ -0,0 +1,36 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var specs_exports = {};
+__export(specs_exports, {
+  CODE_GRAPH_UNSUPPORTED_FEATURES: () => CODE_GRAPH_UNSUPPORTED_FEATURES
+});
+module.exports = __toCommonJS(specs_exports);
+const CODE_GRAPH_UNSUPPORTED_FEATURES = `
+## Unsupported Features
+
+Here are the unsupported nodes and relationships:
+
+- FunctionDeclaration
+- InterfaceDeclaration
+- TypeAliasDeclaration
+- TypeParameterDeclaration
+`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CODE_GRAPH_UNSUPPORTED_FEATURES
+});

package/libs/cli/code-graph/src/lib/expressions/call-expressions.graph.js

@@ -0,0 +1,28 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var call_expressions_graph_exports = {};
+__export(call_expressions_graph_exports, {
+  addCallExpressionNode: () => addCallExpressionNode
+});
+module.exports = __toCommonJS(call_expressions_graph_exports);
+const addCallExpressionNode = (classCodeGraph, parentId, callExpr, targetId, getMatchingByName) => {
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addCallExpressionNode
+});

package/libs/cli/code-graph/src/lib/fixtures/reactive-event-bus/src/app/examples.event-bus.js

@@ -0,0 +1,53 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+var examples_event_bus_exports = {};
+__export(examples_event_bus_exports, {
+  PrimitiveEventModelEventBus: () => PrimitiveEventModelEventBus
+});
+module.exports = __toCommonJS(examples_event_bus_exports);
+var import_core = require("@angular/core");
+var import_rxjs = require("rxjs");
+let PrimitiveEventModelEventBus = class {
+  constructor() {
+    this.behaviorSubject = new import_rxjs.BehaviorSubject("");
+  }
+  publish(event) {
+    this.behaviorSubject.next(event);
+  }
+  subscribe() {
+    return this.behaviorSubject.asObservable();
+  }
+};
+PrimitiveEventModelEventBus = __decorateClass([
+  (0, import_core.Injectable)({
+    providedIn: "root"
+  })
+], PrimitiveEventModelEventBus);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PrimitiveEventModelEventBus
+});

package/libs/cli/code-graph/src/lib/method-declarations/index.js

@@ -0,0 +1,23 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var method_declarations_exports = {};
+module.exports = __toCommonJS(method_declarations_exports);
+__reExport(method_declarations_exports, require("./method-declarations.doc"), module.exports);
+__reExport(method_declarations_exports, require("./method-declarations.graph"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./method-declarations.doc"),
+  ...require("./method-declarations.graph")
+});

package/libs/cli/code-graph/src/lib/method-declarations/method-declarations.doc.js

@@ -0,0 +1,106 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var method_declarations_doc_exports = {};
+__export(method_declarations_doc_exports, {
+  METHOD_DECLARATION_DOC: () => METHOD_DECLARATION_DOC,
+  METHOD_DECLARATION_EDGE_TYPES: () => METHOD_DECLARATION_EDGE_TYPES,
+  METHOD_DECLARATION_EXAMPLES: () => METHOD_DECLARATION_EXAMPLES
+});
+module.exports = __toCommonJS(method_declarations_doc_exports);
+var import_core = require("../core/core");
+var import_types = require("../types");
+var METHOD_DECLARATION_EDGE_TYPES = /* @__PURE__ */ ((METHOD_DECLARATION_EDGE_TYPES2) => {
+  METHOD_DECLARATION_EDGE_TYPES2["HAS_PARAMETER"] = "HAS_PARAMETER";
+  return METHOD_DECLARATION_EDGE_TYPES2;
+})(METHOD_DECLARATION_EDGE_TYPES || {});
+const STUB = `class Test {
+  num = 1;
+  str = 'test';
+  bool = true;
+
+  queryMethod() {
+    return this.num;
+  }
+
+  commandMethod(param1: number) {
+    this.num = this.num + param1;
+  }
+}`;
+const METHOD_DECLARATION_EXAMPLES = [
+  {
+    userPrompt: "Find all method declarations",
+    given: STUB,
+    when: `MATCH (methDecl:MethodDeclaration) RETURN methDecl`,
+    then: [
+      [
+        {
+          labels: ["MethodDeclaration"],
+          name: "queryMethod"
+        }
+      ],
+      [
+        {
+          labels: ["MethodDeclaration"],
+          name: "commandMethod"
+        }
+      ]
+    ]
+  },
+  {
+    userPrompt: "show me all method declarations that are parameterless",
+    given: STUB,
+    when: `MATCH (m:MethodDeclaration) OPTIONAL MATCH (m)-[:${"HAS_PARAMETER" /* HAS_PARAMETER */}]->(p:Parameter) WHERE p IS NULL RETURN m`,
+    then: [
+      [
+        {
+          labels: ["MethodDeclaration"],
+          name: "queryMethod"
+        }
+      ]
+    ]
+  }
+];
+const METHOD_DECLARATION_DOC = {
+  id: "method-declaration",
+  name: "MethodDeclaration",
+  schema: {
+    ...import_core.NameableSchema,
+    modifiers: "string[]",
+    body: "string"
+  },
+  relationships: {
+    ["HAS_PARAMETER" /* HAS_PARAMETER */]: {
+      examples: [
+        `(m:MethodDeclaration)-[:${"HAS_PARAMETER" /* HAS_PARAMETER */}]->(p:Parameter)`
+      ]
+    },
+    [import_types.TYPE_INFO_EDGE_TYPES.HAS_TYPE]: {
+      examples: [
+        `(m:MethodDeclaration)-[:${import_types.TYPE_INFO_EDGE_TYPES.HAS_TYPE}]->(t:Type)`
+      ]
+    }
+  },
+  description: `The node represents TypeScript AST kind: MethodDeclaration.`,
+  examples: METHOD_DECLARATION_EXAMPLES
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  METHOD_DECLARATION_DOC,
+  METHOD_DECLARATION_EDGE_TYPES,
+  METHOD_DECLARATION_EXAMPLES
+});

package/libs/cli/code-graph/src/lib/method-declarations/method-declarations.graph.js

@@ -0,0 +1,56 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var method_declarations_graph_exports = {};
+__export(method_declarations_graph_exports, {
+  appendClassMethodsGraph: () => appendClassMethodsGraph
+});
+module.exports = __toCommonJS(method_declarations_graph_exports);
+var import_class_declarations = require("../class-declarations/class-declarations.doc");
+var import_code = require("../code.graph");
+var import_core = require("../core/core");
+var import_method_declarations = require("./method-declarations.doc");
+const appendClassMethodsGraph = (classCodeGraph, classId, classImplementation) => {
+  classImplementation.methods.forEach((m) => {
+    const methodNode = (0, import_core.extendNameable)(m, {
+      modifiers: m.modifiers,
+      body: m.body
+    });
+    (0, import_code.addNode)(classCodeGraph, methodNode);
+    (0, import_code.addEdge)(classCodeGraph, {
+      source: classId,
+      target: methodNode.id,
+      type: import_class_declarations.CLASS_DECLARATION_EDGE_TYPES.HAS_METHOD
+    });
+    appendMethodParametersGraph(classCodeGraph, methodNode.id, m);
+  });
+};
+const appendMethodParametersGraph = (classCodeGraph, methodId, method) => {
+  method.parameters.forEach((p) => {
+    const node = (0, import_core.extendNameable)(p);
+    (0, import_code.addNode)(classCodeGraph, node);
+    (0, import_code.addEdge)(classCodeGraph, {
+      source: methodId,
+      target: node.id,
+      type: import_method_declarations.METHOD_DECLARATION_EDGE_TYPES.HAS_PARAMETER
+    });
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendClassMethodsGraph
+});

package/libs/cli/code-graph/src/lib/parameters/index.js

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parameters_exports = {};
+__export(parameters_exports, {
+  PARAMETER_DOC: () => PARAMETER_DOC
+});
+module.exports = __toCommonJS(parameters_exports);
+var import_core = require("../core/core");
+var import_types = require("../types");
+const PARAMETER_DOC = {
+  id: "parameter",
+  name: "Parameter",
+  schema: {
+    ...import_core.NameableSchema
+  },
+  relationships: {
+    [import_types.TYPE_INFO_EDGE_TYPES.HAS_TYPE]: {
+      examples: [`(p:Parameter)-[:${import_types.TYPE_INFO_EDGE_TYPES.HAS_TYPE}]->(t:Type)`]
+    }
+  },
+  description: `The node represents TypeScript AST kind: Parameter.`,
+  examples: []
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PARAMETER_DOC
+});

package/libs/cli/code-graph/src/lib/property-declarations/abstractions/reactive-state.evals.js

@@ -0,0 +1,139 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var reactive_state_evals_exports = {};
+__export(reactive_state_evals_exports, {
+  DIRECT_ACCESS: () => DIRECT_ACCESS,
+  INDIRECT_ACCESS: () => INDIRECT_ACCESS,
+  INITIALIZER_AS_CALL: () => INITIALIZER_AS_CALL
+});
+module.exports = __toCommonJS(reactive_state_evals_exports);
+const DIRECT_ACCESS = {
+  stub: `
+  import { ReplaySubject } from "rxjs";
+
+export class TestService {
+  private readonly reactive = new ReplaySubject<string>();
+  
+  methodA() {
+    this.reactive.next('Hello world');
+  }
+
+  methodB() {
+    return this.reactive.asObservable();
+  }
+}`,
+  answer: {
+    property: {
+      name: "reactive"
+    },
+    getters: [
+      {
+        name: "methodB"
+      }
+    ],
+    setters: [
+      {
+        name: "methodA"
+      }
+    ]
+  }
+};
+const INDIRECT_ACCESS = {
+  stub: `import { ReplaySubject } from "rxjs";
+
+export class TestService {
+  private readonly reactive = new ReplaySubject<string>();
+  
+  methodA() {
+    this.reactive.next('Hello world');
+  }
+
+  methodB() {
+    return this.methodC();
+  }
+
+  methodC() {
+    return this.reactive.asObservable();
+  }
+}`,
+  answer: {
+    property: {
+      name: "reactive"
+    },
+    getters: [
+      {
+        name: "methodC"
+      },
+      {
+        name: "methodB"
+      }
+    ],
+    setters: [
+      {
+        name: "methodA"
+      }
+    ]
+  }
+};
+const INITIALIZER_AS_CALL = {
+  stub: `import { ReplaySubject } from "rxjs";
+
+export class TestService {
+  private readonly prop = this.methodD();
+  
+  methodA() {
+    this.prop.next('Hello world');
+  }
+
+  methodB() {
+    return this.methodC();
+  }
+
+  methodC() {
+    return this.prop.asObservable();
+  }
+
+  methodD() {
+    return new ReplaySubject<string>();
+  }
+}`,
+  answer: {
+    property: {
+      name: "prop"
+    },
+    getters: [
+      {
+        name: "methodC"
+      },
+      {
+        name: "methodB"
+      }
+    ],
+    setters: [
+      {
+        name: "methodA"
+      }
+    ]
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DIRECT_ACCESS,
+  INDIRECT_ACCESS,
+  INITIALIZER_AS_CALL
+});