@akanjs/language 3.2.0-rc.0 → 3.2.0-rc.10

package/adaptorResolver.d.ts

@@ -0,0 +1,18 @@
+import type { AkanGraphEdgeKind, AkanGraphLocation, AkanGraphNode, AkanGraphNodeKind } from "akanjs/common/akanGraph.ts";
+import type { AkanGraphSource } from "./akanGraph";
+import { type GuardResolver } from "./guardResolver";
+import type { AkanSpan, Extent, FileFacts, ServiceClassFact } from "./moduleFacts";
+export interface GraphSink {
+    key: (kind: AkanGraphNodeKind, owner: string | null, scope: string) => string;
+    addNode: (id: string, kind: AkanGraphNodeKind, owner: string | null, name: string, span: AkanSpan | null, detail: string[]) => AkanGraphNode;
+    addEdge: (from: string, to: string, kind: AkanGraphEdgeKind, label: string | null, at: AkanGraphLocation | null) => void;
+    digest: (node: AkanGraphNode, text: string | undefined, extent: Extent) => void;
+    location: (span: AkanSpan) => AkanGraphLocation;
+}
+export declare class AdaptorResolver {
+    #private;
+    constructor(source: AkanGraphSource, resolver: GuardResolver, sink: GraphSink);
+    declare(facts: FileFacts[]): void;
+    addService(refName: string, service: ServiceClassFact, file: FileFacts): void;
+    pluggedOf(owner: string | null, module: string | null, field: string): string[];
+}

package/akanGraph.d.ts

@@ -1,7 +1,7 @@
 import type { AkanGraph } from "akanjs/common/akanGraph.ts";
 import type * as TS from "typescript";
 import type { Ts } from "./ast";
-import { type AkanFactReader, type FileFacts } from "./moduleFacts";
+import type { AkanFactReader, FileFacts } from "./moduleFacts";
 import type { AkanTarget } from "./nameTable";
 export interface AkanGraphSource {
     ts: Ts;

package/akanGraphDiff.d.ts

@@ -6,5 +6,5 @@ export interface AkanGraphChanges extends AkanGraph {
 }
 export declare class AkanGraphDiff {
     #private;
-    static between(base: AkanGraph, head: AkanGraph): AkanGraphChanges;
+    static between(given: AkanGraph, head: AkanGraph): AkanGraphChanges;
 }

package/escapeRegExp.d.ts

@@ -0,0 +1 @@
+export declare const escapeRegExp: (text: string) => string;

package/guardFacts.d.ts

@@ -0,0 +1,50 @@
+import type * as TS from "typescript";
+import type { AkanAst, Ts } from "./ast";
+import type { AkanSpan, Extent, ImportFact, MemberFact } from "./moduleFacts";
+export interface GuardFact extends MemberFact {
+    scope: string | null;
+    doc: string | null;
+    factory: string | null;
+    layers: number;
+}
+export interface GuardVia {
+    callee: string;
+    layers: number;
+}
+export interface GuardFactoryFact extends MemberFact {
+    scope: string | null;
+    doc: string | null;
+    direct: boolean;
+    via: GuardVia[];
+    layers: number;
+}
+export interface GuardCallFact extends MemberFact {
+    callee: string;
+    kind: "call" | "extends";
+    scope: string | null;
+    doc: string | null;
+    layers: number;
+}
+export interface InPlaceGuard {
+    call: TS.CallExpression;
+    name: string;
+}
+export declare const guardLabelOf: (guard: string, labels: Record<string, string>) => string;
+interface GuardReaderBase {
+    spanOf: (source: TS.SourceFile, node: TS.Node) => AkanSpan;
+    extentOf: (source: TS.SourceFile, node: TS.Node) => Extent;
+    unwrap: (expression: TS.Expression) => TS.Expression;
+    docOf: (source: TS.SourceFile, node: TS.Node) => string | null;
+}
+export declare const createGuardFactReader: (ts: Ts, ast: AkanAst, base: GuardReaderBase) => {
+    guardsIn: (source: TS.SourceFile, object: TS.ObjectLiteralExpression | undefined, made: InPlaceGuard[], member: string) => string[];
+    guardsOf: (source: TS.SourceFile, imports: ImportFact[], madeInPlace: InPlaceGuard[]) => {
+        guards: GuardFact[];
+        guardFactories: GuardFactoryFact[];
+        guardCalls: GuardCallFact[];
+        guardLabels: {
+            [k: string]: string;
+        };
+    };
+};
+export {};

package/guardResolver.d.ts

@@ -0,0 +1,75 @@
+import type * as TS from "typescript";
+import type { AkanGraphSource } from "./akanGraph";
+import { type AkanSpan, type Extent, type FileFacts } from "./moduleFacts";
+import type { RouteFactReader } from "./routeFacts";
+export type GuardSite = Pick<FileFacts, "fileName" | "owner" | "imports">;
+interface GuardPart {
+    fileName: string;
+    extent: Extent;
+}
+export interface DeclaredGuard {
+    name: string;
+    owner: string | null;
+    span: AkanSpan;
+    scope: string | null;
+    doc: string | null;
+    parts: GuardPart[];
+    file: string | null;
+    label?: string;
+}
+type GuardLookup = {
+    guard: DeclaredGuard;
+} | {
+    name: string;
+    from: string | undefined;
+} | {
+    external: true;
+};
+interface Reexport {
+    name: string;
+    from: string | null;
+}
+interface StarExports {
+    owners: string[];
+    packages: string[];
+    paths: string[];
+    isOpaque: boolean;
+}
+interface ModuleExports {
+    named: (Reexport & {
+        fileName: string;
+    }) | null;
+    stars: string[];
+}
+interface Declaration {
+    source: TS.SourceFile;
+    statement: TS.Statement;
+    declared: TS.Node;
+    extent: Extent;
+    name: string;
+}
+export declare const frameworkOwner = "akanjs";
+export declare const frameworkPattern: RegExp;
+export declare class GuardResolver {
+    #private;
+    constructor(source: AkanGraphSource, routes: RouteFactReader);
+    find(local: string, site: GuardSite): GuardLookup;
+    madeInPlace(fileName: string, name: string): DeclaredGuard | undefined;
+    declare(facts: FileFacts[]): DeclaredGuard[];
+    reexportOf(owner: string, name: string, near: string | null): {
+        local: string;
+        site: GuardSite;
+    } | null;
+    declarationOf(owner: string, name: string, near: string | null, depth?: number): Declaration | null;
+    starExportsOf(owner: string, near: string): StarExports;
+    exportsAt(path: string, name: string): ModuleExports;
+    hasModule(path: string): boolean;
+    packagesUnder(owner: string, folder: string): string[];
+    declares(owner: string, name: string): boolean;
+    declaresAt(path: string, name: string): boolean;
+    inOwner(fileName: string, owner: string | null): string;
+    ownerOfSpecifier(fileName: string, specifier: string): string | undefined;
+    pathOfSpecifier(fileName: string, specifier: string): string | null;
+    visible(target: string | null, from: string | null): boolean;
+}
+export {};