@proteinjs/reflection-build 1.4.4 → 1.4.6

package/test/examples/source-repository/b/node_modules/@proteinjs/reflection/src/SourceRepository.ts

@@ -0,0 +1,250 @@
+import { Graph } from '@dagrejs/graphlib';
+import { graphSerializer, isInstanceOf } from '@proteinjs/util';
+import { SourceType } from './sourceGraphTypes';
+import {
+  VariableDeclaration,
+  TypeAliasDeclaration,
+  ClassDeclaration,
+  InterfaceDeclaration,
+  Class,
+  Variable,
+  TypeAlias,
+  Interface,
+  PackageScope,
+} from './types';
+import { FlattenedSourceGraph, flattenSourceGraph } from './FlattenedSourceGraph';
+import { SOURCE_REPOSITORY_FILTER_QUALIFIED_NAME, getSourceRepositoryFilters } from './SourceRepositoryFilter';
+
+type TypeMap = { [qualifiedName: string]: Interface | TypeAlias | Class | Variable };
+
+export class SourceRepository {
+  public readonly sourceGraph = new Graph();
+  private readonly sourceLinks: { [qualifiedName: string]: any } = {};
+  public flattenedSourceGraph: FlattenedSourceGraph = { variables: {}, typeAliases: {}, classes: {}, interfaces: {} };
+  // private readonly typeCache: { [type: string]: (ClassDeclaration|VariableDeclaration)[] } = {};
+  private readonly objectCache: { [type: string]: any[] } = {};
+
+  private constructor() {}
+
+  static get(): SourceRepository {
+    if (!SourceRepository.getGlobal().__proteinjs_reflection_SourceRepository) {
+      SourceRepository.getGlobal().__proteinjs_reflection_SourceRepository = new SourceRepository();
+    }
+
+    return SourceRepository.getGlobal().__proteinjs_reflection_SourceRepository;
+  }
+
+  private static getGlobal(): any {
+    if (typeof window !== 'undefined') {
+      return window;
+    }
+
+    return globalThis;
+  }
+
+  interface(qualifiedInterfaceName: string) {
+    return this.flattenedSourceGraph.interfaces[qualifiedInterfaceName];
+  }
+
+  interfaceExtends(_interface: Interface, type: string) {
+    return typeof _interface.allParents[type] !== 'undefined';
+  }
+
+  /**
+   * Same as SourceRepository.objects except assumes it will find only 1 object.
+   *
+   * @param extendingType a Type or Interface that the Class or Variable extends
+   * @return variable or instantiated class that extends `extendingType`
+   */
+  object<T>(extendingType: string): T {
+    return this.objects<T>(extendingType)[0];
+  }
+
+  /**
+   * @param extendingType a Type, Interface, or Class that the Class or Variable extends
+   * @return variables and instantiated classes that extend `extendingType`
+   */
+  objects<T>(extendingType: string): T[] {
+    if (this.objectCache[extendingType]) {
+      return this.objectCache[extendingType];
+    }
+
+    const baseChildren = this.baseChildren(extendingType);
+    const extendingObjects: T[] = [];
+    for (const baseChildQualifiedName in baseChildren) {
+      const child = baseChildren[baseChildQualifiedName];
+      if (isInstanceOf(child, Class)) {
+        extendingObjects.push(new (child as any)._constructor());
+      } else if (isInstanceOf(child, Variable)) {
+        extendingObjects.push((child as any).value);
+      }
+    }
+
+    this.objectCache[extendingType] = extendingObjects;
+    return extendingObjects;
+  }
+
+  /**
+   * @param extendingType a Type, Interface, or Class that the Class or Variable extends
+   * @returns a hashmap (key is qualified name) of base child types (vs the instantiated objects provided by the objects method) that extend `extendingType`
+   */
+  baseChildren(extendingType: string): TypeMap {
+    const _interface = SourceRepository.get().flattenedSourceGraph.interfaces[extendingType];
+    const typeAlias = SourceRepository.get().flattenedSourceGraph.typeAliases[extendingType];
+    const _class = SourceRepository.get().flattenedSourceGraph.classes[extendingType];
+    let baseChildren: TypeMap;
+    if (_interface) {
+      baseChildren = _interface.baseChildren;
+    } else if (typeAlias) {
+      baseChildren = typeAlias.baseChildren;
+    } else if (_class) {
+      baseChildren = _class.baseChildren;
+    } else {
+      throw new Error(`Unable to find type: ${extendingType}`);
+    }
+
+    if (extendingType === SOURCE_REPOSITORY_FILTER_QUALIFIED_NAME) {
+      return baseChildren;
+    }
+
+    return this.filterObjects(baseChildren);
+  }
+
+  /**
+   * @param extendingType a Type, Interface, or Class that the Class or Variable extends
+   * @returns a hashmap (key is qualified name) of direct child types (vs the instantiated objects provided by the objects method) that extend `extendingType`
+   */
+  directChildren(extendingType: string): TypeMap {
+    const _interface = SourceRepository.get().flattenedSourceGraph.interfaces[extendingType];
+    const typeAlias = SourceRepository.get().flattenedSourceGraph.typeAliases[extendingType];
+    const _class = SourceRepository.get().flattenedSourceGraph.classes[extendingType];
+    let directChildren: any;
+    if (_interface) {
+      directChildren = _interface.directChildren;
+    } else if (typeAlias) {
+      directChildren = typeAlias.directChildren;
+    } else if (_class) {
+      directChildren = _class.directChildren;
+    } else {
+      throw new Error(`Unable to find type: ${extendingType}`);
+    }
+
+    if (extendingType === SOURCE_REPOSITORY_FILTER_QUALIFIED_NAME) {
+      return directChildren;
+    }
+
+    return this.filterObjects(directChildren);
+  }
+
+  private filterObjects(typeMap: TypeMap): TypeMap {
+    const filteredTypeMap: TypeMap = {};
+    const filters = getSourceRepositoryFilters();
+    for (const qualifiedName of Object.keys(typeMap)) {
+      const packageScope = typeMap[qualifiedName];
+      let filtered = true;
+      for (const filter of filters) {
+        if (!filter.filterObject(qualifiedName)) {
+          filtered = false;
+          break;
+        }
+      }
+
+      if (filtered) {
+        filteredTypeMap[qualifiedName] = packageScope;
+      }
+    }
+
+    return filteredTypeMap;
+  }
+
+  static merge(serializedSourceGraph: string, sourceLinks: { [qualifiedName: string]: any }) {
+    const unescapedSerializedSourceGraph = serializedSourceGraph.replace(/\\'/g, "'");
+    const sourceGraph = graphSerializer.deserialize(unescapedSerializedSourceGraph);
+    for (const nodeName of sourceGraph.nodes()) {
+      const nodeValue = sourceGraph.node(nodeName);
+      if (!nodeValue) {
+        continue;
+      }
+
+      SourceRepository.get().sourceGraph.setNode(nodeName, SourceRepository.deserializeClass(nodeValue));
+    }
+
+    for (const edge of sourceGraph.edges()) {
+      const edgeValue = sourceGraph.edge(edge);
+      SourceRepository.get().sourceGraph.setEdge(edge, edgeValue);
+    }
+
+    Object.assign(SourceRepository.get().sourceLinks, sourceLinks);
+    SourceRepository.get().flattenedSourceGraph = flattenSourceGraph(
+      SourceRepository.get().sourceGraph,
+      SourceRepository.get().sourceLinks
+    );
+  }
+
+  private static deserializeClass(classJson: any): any {
+    if (classJson.sourceType === SourceType.variable) {
+      return VariableDeclaration.deserialize(classJson);
+    } else if (classJson.sourceType === SourceType.typeAlias) {
+      return TypeAliasDeclaration.deserialize(classJson);
+    } else if (classJson.sourceType === SourceType.class) {
+      return ClassDeclaration.deserialize(classJson);
+    } else if (classJson.sourceType === SourceType.interface) {
+      return InterfaceDeclaration.deserialize(classJson);
+    }
+
+    return classJson;
+  }
+
+  // objects<T>(type: string): T[] {
+  // 	if (!this.objectCache[type]) {
+  // 		this.objectCache[type] = this.types(type).map((type) => {
+  // 			if (type instanceof VariableDeclaration)
+  // 				return type.value;
+
+  // 			if (type instanceof ClassDeclaration)
+  // 				return new type._constructor();
+
+  // 			return null;
+  // 		});
+  // 	}
+
+  // 	return this.objectCache[type];
+  // }
+
+  // types(parentType: string): (ClassDeclaration|VariableDeclaration)[] {
+  // 	if (!this.typeCache[parentType]) {
+  // 		const node = this.sourceGraph.node(parentType);
+  // 		if (!node)
+  // 			throw new Error(`Failed to find types, reason: parent type does not exist: ${parentType}`);
+
+  // 		const collectedTypes: (ClassDeclaration|VariableDeclaration)[] = [];
+  // 		this.collectTypes(parentType, collectedTypes);
+  // 		this.typeCache[parentType] = collectedTypes;
+  // 	}
+
+  // 	return this.typeCache[parentType];
+  // }
+
+  // private collectTypes(type: string, collectedTypes: (ClassDeclaration|VariableDeclaration)[]): void {
+  // 	const childTypes = this.sourceGraph.successors(type);
+  // 	if (!childTypes)
+  // 		return;
+
+  // 	for (const childType of childTypes) {
+  // 		const childNode = this.sourceGraph.node(childType);
+  // 		if (!childNode)
+  // 			continue;
+
+  // 		const sourceLink = this.sourceLinks[childNode.qualifiedName];
+  // 		if (childNode instanceof VariableDeclaration) {
+  // 			childNode.value = sourceLink;
+  // 			collectedTypes.push(childNode);
+  // 		} else if (childNode instanceof ClassDeclaration && !childNode.isAbstract) {
+  // 			childNode._constructor = sourceLink;
+  // 			collectedTypes.push(childNode);
+  // 		}
+
+  // 		this.collectTypes(childType, collectedTypes);
+  // 	}
+  // }
+}

package/test/examples/source-repository/b/node_modules/@proteinjs/reflection/src/SourceRepositoryFilter.ts

@@ -0,0 +1,15 @@
+import { Loadable } from './Loadable';
+import { SourceRepository } from './SourceRepository';
+
+export const SOURCE_REPOSITORY_FILTER_QUALIFIED_NAME = '@proteinjs/reflection/SourceRepositoryFilter';
+export const getSourceRepositoryFilters = () =>
+  SourceRepository.get().objects<SourceRepositoryFilter>(SOURCE_REPOSITORY_FILTER_QUALIFIED_NAME);
+
+export interface SourceRepositoryFilter extends Loadable {
+  /**
+   * Filter objects that would be returned by `SourceRepository.object` and `SourceRepository.objects`
+   * @param qualifiedName the package-qualified name of the object to be filtered (ie. `@dependency/package/ClassName`)
+   * @return true if the object should be returned by the `SourceRepository`
+   */
+  filterObject(qualifiedName: string): boolean;
+}

package/test/examples/source-repository/b/node_modules/@proteinjs/reflection/src/sourceGraphTypes.ts

@@ -0,0 +1,14 @@
+export enum SourceType {
+  variable,
+  typeAlias,
+  class,
+  interface,
+}
+
+export enum SourceRelationship {
+  hasType = 'has type',
+  extendsType = 'extends type',
+  extendsClass = 'extends class',
+  implementsInterface = 'implements interface',
+  extendsInterface = 'extends interface',
+}

package/test/examples/source-repository/b/node_modules/@proteinjs/reflection/src/types.ts

@@ -0,0 +1,236 @@
+export abstract class PackageScope {
+  public readonly qualifiedName: string;
+
+  constructor(
+    public readonly packageName: string,
+    public readonly name: string,
+    public readonly filePath?: string
+  ) {
+    this.qualifiedName = `${packageName}/${name}`;
+  }
+}
+
+export class Variable extends PackageScope {
+  constructor(
+    packageName: string,
+    name: string,
+    filePath: string,
+    public readonly isExported: boolean,
+    public readonly isConst: boolean,
+    public readonly value: any,
+    public readonly typeParameters: { [qualifiedName: string]: (TypeAlias | Interface)[] } = {},
+    public directParentTypes: { [qualifiedName: string]: TypeAlias | Interface } = {},
+    public allParentTypes: { [qualifiedName: string]: TypeAlias | Interface } = {},
+    public rootParentTypes: { [qualifiedName: string]: TypeAlias | Interface } = {}
+  ) {
+    super(packageName, name, filePath);
+  }
+}
+
+export class TypeAlias extends PackageScope {
+  constructor(
+    packageName: string,
+    name: string,
+    filePath?: string,
+    public readonly typeParameters: { [qualifiedName: string]: (TypeAlias | Interface)[] } = {},
+    public readonly directParents: { [qualifiedName: string]: TypeAlias | Interface } = {},
+    public allParents: { [qualifiedName: string]: TypeAlias | Interface } = {},
+    public rootParents: { [qualifiedName: string]: TypeAlias | Interface } = {},
+    public directChildren: { [qualifiedName: string]: TypeAlias | Variable } = {},
+    public allChildren: { [qualifiedName: string]: TypeAlias | Variable } = {},
+    public baseChildren: { [qualifiedName: string]: TypeAlias | Variable } = {}
+  ) {
+    super(packageName, name, filePath);
+  }
+}
+
+export class Class extends PackageScope {
+  constructor(
+    packageName: string,
+    name: string,
+    filePath: string,
+    public readonly isAbstract: boolean,
+    public readonly isStatic: boolean,
+    public readonly visibility: Visibility,
+    public readonly properties: Property[],
+    public readonly methods: Method[],
+    public readonly _constructor: any,
+    public readonly directParents: { [qualifiedName: string]: Class | Interface | TypeAlias } = {},
+    public readonly typeParameters: { [qualifiedName: string]: (TypeAlias | Interface | TypeAlias)[] } = {},
+    public allParents: { [qualifiedName: string]: Class | Interface | TypeAlias } = {},
+    public rootParents: { [qualifiedName: string]: Class | Interface | TypeAlias } = {},
+    public directChildren: { [qualifiedName: string]: Class } = {},
+    public allChildren: { [qualifiedName: string]: Class } = {},
+    public baseChildren: { [qualifiedName: string]: Class } = {}
+  ) {
+    super(packageName, name, filePath);
+  }
+}
+
+export class Interface extends PackageScope {
+  constructor(
+    packageName: string,
+    name: string,
+    public readonly properties: Property[],
+    public readonly methods: Method[],
+    filePath?: string,
+    public readonly typeParameters: { [qualifiedName: string]: (TypeAlias | Interface)[] } = {},
+    public readonly directParents: { [qualifiedName: string]: Interface | TypeAlias } = {},
+    public allParents: { [qualifiedName: string]: Interface | TypeAlias } = {},
+    public rootParents: { [qualifiedName: string]: Interface | TypeAlias } = {},
+    public readonly directChildren: { [qualifiedName: string]: Interface | TypeAlias | Class | Variable } = {},
+    public allChildren: { [qualifiedName: string]: Interface | TypeAlias | Class | Variable } = {},
+    public baseChildren: { [qualifiedName: string]: Interface | TypeAlias | Class | Variable } = {}
+  ) {
+    super(packageName, name, filePath);
+  }
+}
+
+export class Method {
+  constructor(
+    public readonly name: string,
+    public readonly returnType: TypeAliasDeclaration | undefined,
+    public readonly isAsync: boolean,
+    public readonly isOptional: boolean,
+    public readonly isAbstract: boolean,
+    public readonly isStatic: boolean,
+    public readonly visibility: Visibility,
+    public readonly parameters: Parameter[]
+    // public readonly variables: VariableDeclaration[]
+  ) {}
+}
+
+export type Visibility = 'public' | 'protected' | 'private' | undefined;
+
+export class Property {
+  constructor(
+    public readonly name: string,
+    public readonly type: TypeAliasDeclaration | undefined,
+    public readonly isOptional: boolean,
+    public readonly isAbstract: boolean,
+    public readonly isStatic: boolean,
+    public readonly visibility: Visibility
+  ) {}
+}
+
+export class Parameter {
+  constructor(
+    public readonly name: string,
+    public readonly type: TypeAliasDeclaration | undefined
+    // public readonly isOptional: boolean
+  ) {}
+}
+
+/**
+ * Declarations are intermediary types created by the parser. They do not contain the deeply-nested, relational
+ * information possible at runtime.
+ *
+ * Note: The declaration types specified in typescript-parser are not used because they are not package-scoped.
+ * The typescript-parser package is a file-level parser, and reflection is a package-level parser.
+ */
+
+export class VariableDeclaration extends PackageScope {
+  constructor(
+    packageName: string,
+    name: string,
+    filePath: string,
+    public type: TypeAliasDeclaration,
+    public isExported: boolean,
+    public isConst: boolean
+  ) {
+    super(packageName, name, filePath);
+  }
+
+  static deserialize(json: any): VariableDeclaration {
+    return new VariableDeclaration(
+      json.packageName,
+      json.name,
+      json.filePath,
+      json.type,
+      json.isExported,
+      json.isConst
+    );
+  }
+}
+
+export class TypeAliasDeclaration extends PackageScope {
+  constructor(
+    packageName: string,
+    name: string,
+    public typeParameters?: string[],
+    public directParents?: TypeAliasDeclaration[],
+    filePath?: string
+  ) {
+    super(packageName, name, filePath);
+  }
+
+  static deserialize(json: any): TypeAliasDeclaration {
+    return new TypeAliasDeclaration(
+      json.packageName,
+      json.name,
+      json.typeParameters,
+      json.directParents,
+      json.filePath
+    );
+  }
+}
+
+export class ClassDeclaration extends PackageScope {
+  constructor(
+    packageName: string,
+    name: string,
+    public readonly isAbstract: boolean,
+    public readonly isStatic: boolean,
+    public readonly visibility: Visibility,
+    public readonly properties: Property[],
+    public readonly methods: Method[],
+    public readonly typeParameters: string[],
+    public readonly directParentInterfaces: InterfaceDeclaration[],
+    public readonly directParentClasses: ClassDeclaration[],
+    filePath?: string
+  ) {
+    super(packageName, name, filePath);
+  }
+
+  static deserialize(json: any): ClassDeclaration {
+    return new ClassDeclaration(
+      json.packageName,
+      json.name,
+      json.isAbstract,
+      json.isStatic,
+      json.visibility,
+      json.properties,
+      json.methods,
+      json.typeParameters,
+      json.directParentInterfaces,
+      json.directParentClasses,
+      json.filePath
+    );
+  }
+}
+
+export class InterfaceDeclaration extends PackageScope {
+  constructor(
+    packageName: string,
+    name: string,
+    public readonly properties: Property[],
+    public readonly methods: Method[],
+    public readonly typeParameters: string[],
+    public readonly directParents: InterfaceDeclaration[],
+    filePath?: string
+  ) {
+    super(packageName, name, filePath);
+  }
+
+  static deserialize(json: any): InterfaceDeclaration {
+    return new InterfaceDeclaration(
+      json.packageName,
+      json.name,
+      json.properties,
+      json.methods,
+      json.typeParameters,
+      json.directParents,
+      json.filePath
+    );
+  }
+}

package/test/examples/source-repository/b/node_modules/@proteinjs/reflection/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "declaration": true,
+    "sourceMap": true,
+    "outDir": "./dist/",
+    "strict": true,
+    "noImplicitAny": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "baseUrl": "./",
+    "paths": { "*": ["types/*"] },
+    "types": ["node", "jest"]
+  },
+  "include": ["./index.ts"]
+}

package/test/examples/source-repository/b/node_modules/@proteinjs/reflection/types/@dagrejs/graphlib.d.ts

@@ -0,0 +1 @@
+export * from 'graphlib';

package/test/examples/source-repository/b/node_modules/@proteinjs/util-node/CHANGELOG.md

@@ -3,6 +3,39 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.8.1](https://github.com/proteinjs/util/compare/@proteinjs/util-node@1.8.0...@proteinjs/util-node@1.8.1) (2026-04-14)
+
+
+### Bug Fixes
+
+* make symlink-workspace portable and self-sufficient ([fa34e5f](https://github.com/proteinjs/util/commit/fa34e5f4f7d4fa6785cda8a4747964904020202d))
+
+
+
+
+
+# [1.8.0](https://github.com/proteinjs/util/compare/@proteinjs/util-node@1.7.3...@proteinjs/util-node@1.8.0) (2026-04-13)
+
+
+### Features
+
+* chmod +x bin files after symlinking local dependencies ([10040cf](https://github.com/proteinjs/util/commit/10040cf8393b9369a997fbaccc1c337ee1871a37))
+
+
+
+
+
+## [1.7.3](https://github.com/proteinjs/util/compare/@proteinjs/util-node@1.7.2...@proteinjs/util-node@1.7.3) (2026-04-13)
+
+
+### Bug Fixes
+
+* create scoped package parent directories before symlinking ([8096064](https://github.com/proteinjs/util/commit/8096064c6c32f7477c1b13df79dd52283a973a91))
+
+
+
+
+
 ## [1.7.2](https://github.com/proteinjs/util/compare/@proteinjs/util-node@1.7.1...@proteinjs/util-node@1.7.2) (2026-03-06)
 
 **Note:** Version bump only for package @proteinjs/util-node