@fluixi/compiler 1.0.0-alpha.83 → 1.0.0-alpha.84

package/dist/analyze/static-graph.d.cts

@@ -0,0 +1,102 @@
+export type StaticNodeKind = 'state' | 'memo' | 'effect' | 'store' | 'resource' | 'component'
+/** Control flow the framework supplies: `Show`, `For`, `Switch`, `Suspense`, `Await`. */
+ | 'control'
+/** The router's own tags: `Router`, `Outlet`, `Link`, `Redirect`. */
+ | 'router'
+/** A server route handler — `GET`, `POST` in an api file. Not a component. */
+ | 'handler';
+export interface StaticNode {
+    id: number;
+    label: string;
+    kind: StaticNodeKind;
+    /** Ids this one names in its body. */
+    deps: number[];
+    writes: number[];
+    /** Never run, so never pulsed. A renderer reads this as "nothing has happened yet". */
+    runs: number;
+    lastPulse: number;
+    source: {
+        file: string;
+        line: number;
+        column: number;
+    };
+    /** The component whose body declares it. */
+    createdIn?: number;
+    /** Where this value is written into the document. */
+    targets?: StaticDomTarget[];
+    /**
+     * The elements this component writes, as a tree, read from the source rather than from a
+     * page. Only what is written literally: anything inside a hole is decided at runtime.
+     */
+    dom?: StaticDomNode[];
+}
+/**
+ * An element a component writes, in the shape a panel already draws.
+ *
+ * Deliberately the same fields as devtools' `DomNode`, minus the ones only a running page
+ * can fill. Mirrored rather than imported: the compiler does not depend on devtools.
+ */
+export interface StaticDomNode {
+    /** The element as written: `div#root`, `span.num`. */
+    label: string;
+    children: StaticDomNode[];
+    /** The component rendered here, when a tag stands in this position rather than an element. */
+    owner?: number;
+    /** Where the tag was written. */
+    at?: {
+        file: string;
+        line: number;
+        column: number;
+    };
+}
+/** Where a value reaches the document, read from the jsx rather than from a running page. */
+export interface StaticDomTarget {
+    /** `content` for a hole between tags, `attribute` for one in a prop. */
+    kind: 'content' | 'attribute';
+    /** The attribute name, when it is one. */
+    name?: string;
+    /** The element as written: `span.num`, `div#root`. */
+    element: string;
+    /** Where the hole is, in the author's file. */
+    source: {
+        file: string;
+        line: number;
+        column: number;
+    };
+}
+export interface StaticGraph {
+    t: number;
+    nodes: StaticNode[];
+    /** Says what this graph is, for a panel that draws both kinds. */
+    static: true;
+}
+export interface StaticGraphFile {
+    path: string;
+    code: string;
+}
+export interface AnalyzeOptions {
+    /**
+     * Where file-routes live, relative to the project root.
+     *
+     * Nothing in the source references these components: the router is handed a table built
+     * from the directory listing, so a page with no signals in it is named nowhere and reads
+     * as a component belonging to nothing. The directory is what says otherwise.
+     *
+     * `routesDir` in fluixi.config; a host that has read the config should pass what it found.
+     * @default 'src/routes'
+     */
+    routesDir?: string;
+    /**
+     * Where file-based API routes live. Same problem as the pages: the handlers are served by
+     * the directory they sit in, so nothing names them and each one draws on its own.
+     *
+     * `apiDir` in fluixi.config.
+     * @default 'src/api'
+     */
+    apiDir?: string;
+}
+/**
+ * Files are analysed independently, then joined: an imported name resolves to the node the
+ * exporting file declared under it, which connects a store to the memo reading it elsewhere.
+ */
+export declare function analyzeReactiveGraph(files: readonly StaticGraphFile[], options?: AnalyzeOptions): StaticGraph;