gofish-ir 0.1.0

package/dist/frontend/jsonSchema.js

@@ -0,0 +1,288 @@
+// <gofish-wiki> AUTO-GENERATED — see covers: in the essay; run `pnpm --filter docs sync-backlinks`
+// @wiki Frontend IR — /internals/frontend/serialization
+// </gofish-wiki>
+/**
+ * Hand-written JSON Schema for the GoFish frontend IR (v0).
+ *
+ * Structural only — defines the document shape, the discriminator unions
+ * for operators / marks / channel values, and the validity envelope. Full
+ * field-level coverage matches `validate.ts`; this file is the wire
+ * artifact (consumed by external tooling, language servers, and the
+ * Python wrapper's parity-test harness).
+ */
+export const FRONTEND_IR_JSON_SCHEMA = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://gofish.graphics/schema/frontend/v0.json",
+    title: "GoFish Frontend IR",
+    description: "Source-level chart specification produced by the v3 fluent API.",
+    type: "object",
+    required: ["irVersion", "ir", "root"],
+    additionalProperties: false,
+    properties: {
+        irVersion: { const: 0 },
+        ir: { const: "gofish-frontend" },
+        $schema: { type: "string" },
+        root: { $ref: "#/$defs/Root" },
+    },
+    $defs: {
+        Root: {
+            oneOf: [
+                { $ref: "#/$defs/ChartIR" },
+                { $ref: "#/$defs/LayerIR" },
+                { $ref: "#/$defs/RawMarkIR" },
+            ],
+        },
+        Origin: {
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                stack: { type: "string" },
+            },
+        },
+        Meta: {
+            type: "object",
+            description: "Optional inline annotations populated by later passes. v0 emitters leave it absent.",
+        },
+        DataIR: {
+            oneOf: [
+                {
+                    type: "object",
+                    required: ["type", "rows"],
+                    properties: {
+                        type: { const: "inline" },
+                        rows: { type: "array", items: { type: "object" } },
+                    },
+                },
+                {
+                    type: "object",
+                    required: ["type", "layer"],
+                    properties: {
+                        type: { const: "select" },
+                        layer: { type: "string" },
+                    },
+                },
+                {
+                    type: "object",
+                    required: ["type"],
+                    properties: {
+                        type: { const: "external" },
+                        id: { type: "string" },
+                    },
+                },
+            ],
+        },
+        ChartIR: {
+            type: "object",
+            required: ["type", "mark"],
+            properties: {
+                type: { const: "chart" },
+                data: { oneOf: [{ $ref: "#/$defs/DataIR" }, { type: "null" }] },
+                operators: { type: "array", items: { $ref: "#/$defs/OperatorIR" } },
+                mark: { $ref: "#/$defs/MarkIR" },
+                options: { type: "object" },
+                zOrder: { type: "number" },
+                origin: { $ref: "#/$defs/Origin" },
+                meta: { $ref: "#/$defs/Meta" },
+            },
+        },
+        LayerIR: {
+            type: "object",
+            required: ["type", "charts"],
+            properties: {
+                type: { const: "layer" },
+                charts: { type: "array", items: { $ref: "#/$defs/ChartIR" } },
+                options: { type: "object" },
+                origin: { $ref: "#/$defs/Origin" },
+                meta: { $ref: "#/$defs/Meta" },
+            },
+        },
+        RawMarkIR: {
+            type: "object",
+            required: ["type", "mark"],
+            properties: {
+                type: { const: "raw-mark" },
+                mark: { $ref: "#/$defs/MarkIR" },
+                options: { type: "object" },
+                origin: { $ref: "#/$defs/Origin" },
+                meta: { $ref: "#/$defs/Meta" },
+            },
+        },
+        OperatorIR: {
+            type: "object",
+            required: ["type"],
+            properties: {
+                type: {
+                    enum: [
+                        "derive",
+                        "spread",
+                        "stack",
+                        "group",
+                        "scatter",
+                        "table",
+                        "log",
+                    ],
+                },
+            },
+        },
+        MarkIR: {
+            oneOf: [
+                { $ref: "#/$defs/LeafMarkIR" },
+                { $ref: "#/$defs/CombinatorMarkIR" },
+                { $ref: "#/$defs/RefMarkIR" },
+            ],
+        },
+        LeafMarkIR: {
+            type: "object",
+            required: ["type"],
+            properties: {
+                type: {
+                    enum: [
+                        "rect",
+                        "circle",
+                        "line",
+                        "area",
+                        "blank",
+                        "ellipse",
+                        "petal",
+                        "text",
+                        "image",
+                        "polygon",
+                        "mark-fn",
+                    ],
+                },
+                name: { type: "string" },
+                label: { $ref: "#/$defs/LabelIR" },
+                constraints: {
+                    type: "array",
+                    items: { $ref: "#/$defs/ConstraintIR" },
+                },
+                zOrder: { type: "number" },
+            },
+        },
+        CombinatorMarkIR: {
+            type: "object",
+            required: ["type", "__combinator", "children"],
+            properties: {
+                type: {
+                    enum: [
+                        "spread",
+                        "stack",
+                        "scatter",
+                        "group",
+                        "table",
+                        "layer",
+                        "arrow",
+                        "connect",
+                        "treemap",
+                        "over",
+                        "inside",
+                        "xor",
+                        "out",
+                        "atop",
+                        "mask",
+                    ],
+                },
+                __combinator: { const: true },
+                options: { type: "object" },
+                children: { type: "array", items: { $ref: "#/$defs/MarkIR" } },
+                name: { type: "string" },
+                label: { $ref: "#/$defs/LabelIR" },
+                constraints: {
+                    type: "array",
+                    items: { $ref: "#/$defs/ConstraintIR" },
+                },
+                zOrder: { type: "number" },
+            },
+        },
+        RefMarkIR: {
+            type: "object",
+            required: ["type", "selection"],
+            properties: {
+                type: { const: "ref" },
+                selection: {
+                    oneOf: [
+                        { type: "string" },
+                        {
+                            type: "array",
+                            items: { oneOf: [{ type: "string" }, { type: "number" }] },
+                        },
+                    ],
+                },
+                name: { type: "string" },
+                label: { $ref: "#/$defs/LabelIR" },
+                zOrder: { type: "number" },
+            },
+        },
+        LabelIR: {
+            // Three shapes: the canonical object form, a boolean shorthand
+            // (`label: true` — let the mark shape decide what to label), and
+            // a string shorthand (`label: "field"` — use this field accessor
+            // with default styling). All three match `LabelIR` in schema.ts.
+            oneOf: [
+                { type: "boolean" },
+                { type: "string" },
+                {
+                    type: "object",
+                    required: ["accessor"],
+                    properties: {
+                        accessor: { type: "string" },
+                        position: { type: "string" },
+                        fontSize: { type: "number" },
+                        color: { type: "string" },
+                        offset: { type: "number" },
+                        minSpace: { type: "number" },
+                        rotate: { type: "number" },
+                    },
+                },
+            ],
+        },
+        ConstraintIR: {
+            type: "object",
+            required: ["type", "refs"],
+            properties: {
+                type: { enum: ["align", "distribute", "zAbove", "zBelow"] },
+                options: { type: "object" },
+                refs: { type: "array", items: { type: "string" } },
+            },
+        },
+        ChannelValue: {
+            description: "Right-hand side of a channel slot. Bare primitives for the shorthand path; tagged objects for the explicit field/datum/literal constructors and Python-bridge sentinels.",
+            oneOf: [
+                { type: "string" },
+                { type: "number" },
+                { type: "boolean" },
+                { type: "null" },
+                {
+                    type: "object",
+                    required: ["type", "name"],
+                    properties: {
+                        type: { const: "field" },
+                        name: { type: "string" },
+                    },
+                },
+                {
+                    type: "object",
+                    required: ["type", "value"],
+                    properties: {
+                        type: { const: "literal" },
+                        value: {},
+                    },
+                },
+                {
+                    type: "object",
+                    required: ["type", "datum"],
+                    properties: {
+                        type: { const: "datum" },
+                        datum: {},
+                        measure: { type: "string" },
+                    },
+                },
+                {
+                    type: "object",
+                    required: ["__gofish_lambda"],
+                    properties: { __gofish_lambda: { type: "string" } },
+                },
+            ],
+        },
+    },
+};

package/dist/frontend/schema.d.ts

@@ -0,0 +1,255 @@
+/**
+ * GoFish Frontend IR — schema types.
+ *
+ * The frontend IR captures a GoFish chart specification at the source level,
+ * before macro expansion and elaboration. v0 mirrors the existing widget
+ * wire format exactly (lowercase type tags, __combinator flag, channel
+ * slots accept strings/numbers/sentinels). See the architecture essay for
+ * the multi-stage design and the planned v0.1+ improvements.
+ */
+/** Top-level wrapper for a serialized GoFish chart. */
+export interface FrontendIRDocument {
+    irVersion: 0;
+    ir: "gofish-frontend";
+    /** Optional URL of the JSON Schema this document claims to conform to. */
+    $schema?: string;
+    root: FrontendIR;
+}
+/** A frontend-IR root is a chart, a multi-chart layer, or a bare mark. */
+export type FrontendIR = ChartIR | LayerIR | RawMarkIR;
+/**
+ * Metadata that any node may carry. v0 emitters leave `meta` unset; later
+ * passes (underlying-space inference, scale resolution, etc.) populate the
+ * relevant fields. The slot is reserved so additive evolution doesn't
+ * require a schema bump.
+ */
+export interface Meta {
+    /** Source-position attribution — populated by future build-time hooks. */
+    loc?: SourceLocation;
+    /** Underlying-space classification — populated post-elaboration. */
+    space?: UnderlyingSpaceAnnotation;
+    /** Open extension for unknown pass-specific annotations. */
+    [key: string]: unknown;
+}
+export interface SourceLocation {
+    file: string;
+    line: number;
+    column: number;
+}
+export interface UnderlyingSpaceAnnotation {
+    type: "SIZE" | "POSITION" | "ORDINAL" | "DIFFERENCE" | "UNDEFINED";
+}
+/** Mixin properties available on every IR node. */
+export interface BaseIRNode {
+    /** User-supplied origin metadata. Currently carries the `.name(...)` value if set. */
+    origin?: Origin;
+    /** Reserved for inline annotations attached by future passes. */
+    meta?: Meta;
+}
+export interface Origin {
+    /** User-supplied name via `.name("bars")` on the v3 fluent builder. */
+    name?: string;
+    /** Optional captured call-site stack — unset in v0. */
+    stack?: string;
+}
+/** A standard chart: data → operators → mark. */
+export interface ChartIR extends BaseIRNode {
+    type: "chart";
+    data?: DataIR | null;
+    operators?: OperatorIR[];
+    mark: MarkIR;
+    options?: Record<string, unknown>;
+    zOrder?: number;
+}
+/** Multiple charts composed on the same canvas. */
+export interface LayerIR extends BaseIRNode {
+    type: "layer";
+    charts: ChartIR[];
+    options?: Record<string, unknown>;
+}
+/** A bare mark, used when no chart-level wrapping is needed. */
+export interface RawMarkIR extends BaseIRNode {
+    type: "raw-mark";
+    mark: MarkIR;
+    options?: Record<string, unknown>;
+}
+/**
+ * The data field on a chart.
+ *
+ * - **Inline rows**: `{type: "inline", rows: [...]}` for charts whose data is
+ *   embedded in the IR.
+ * - **Select reference**: `{type: "select", layer: "name"}` resolves a sibling
+ *   chart's named-mark output at deserialize time.
+ * - **External**: `{type: "external", id?: "..."}` indicates data ships over a
+ *   sidecar transport (anywidget's `arrow_data` trait) and the id keys into it.
+ */
+export type DataIR = {
+    type: "inline";
+    rows: Array<Record<string, unknown>>;
+} | {
+    type: "select";
+    layer: string;
+} | {
+    type: "external";
+    id?: string;
+};
+export type OperatorIR = DeriveOperator | SpreadOperator | StackOperator | GroupOperator | ScatterOperator | TableOperator | LogOperator;
+/**
+ * `derive(fn)` — opaque user transformation. Function bodies are not
+ * serializable; the IR carries a bridge handle (`lambdaId`) when the
+ * Python widget is the producer, and is otherwise empty.
+ */
+export interface DeriveOperator extends BaseIRNode {
+    type: "derive";
+    lambdaId?: string;
+}
+export interface SpreadOperator extends BaseIRNode {
+    type: "spread";
+    by?: string;
+    dir?: "x" | "y";
+    spacing?: number;
+    alignment?: string;
+    sharedScale?: boolean;
+    mode?: "edge" | "center";
+    reverse?: boolean;
+}
+export interface StackOperator extends BaseIRNode {
+    type: "stack";
+    by?: string;
+    dir?: "x" | "y";
+    alignment?: string;
+    sharedScale?: boolean;
+    mode?: "edge" | "center";
+    reverse?: boolean;
+}
+export interface GroupOperator extends BaseIRNode {
+    type: "group";
+    by: string;
+}
+export interface ScatterOperator extends BaseIRNode {
+    type: "scatter";
+    by?: string;
+    x?: ChannelValue;
+    y?: ChannelValue;
+    xMin?: ChannelValue;
+    xMax?: ChannelValue;
+    yMin?: ChannelValue;
+    yMax?: ChannelValue;
+    alignment?: string;
+}
+export interface TableOperator extends BaseIRNode {
+    type: "table";
+    by: {
+        x: string;
+        y: string;
+    };
+    spacing?: number | [number, number];
+    numCols?: number;
+}
+export interface LogOperator extends BaseIRNode {
+    type: "log";
+    label?: string;
+}
+export type MarkIR = LeafMarkIR | CombinatorMarkIR | RefMarkIR;
+export type LeafMarkType = "rect" | "circle" | "line" | "area" | "blank" | "ellipse" | "petal" | "text" | "image" | "polygon" | "mark-fn";
+export type CombinatorMarkType = "spread" | "stack" | "scatter" | "group" | "table" | "layer" | "arrow" | "connect" | "treemap" | "over" | "inside" | "xor" | "out" | "atop" | "mask";
+/**
+ * A leaf shape mark. Channel-valued props (`h`, `w`, `fill`, `x`, `y`, …)
+ * appear directly on the object alongside the well-known fields. TypeScript
+ * cannot precisely express the union of channel values per shape, so the
+ * index signature is permissive — mirrors the existing widget interface.
+ */
+export interface LeafMarkIR extends BaseIRNode {
+    type: LeafMarkType;
+    name?: string;
+    label?: LabelIR;
+    constraints?: ConstraintIR[];
+    zOrder?: number;
+    [key: string]: unknown;
+}
+/**
+ * A combinator-form operator used as a mark (e.g. `spread([m1, m2])`).
+ * Distinguished from the operator-form by the `__combinator: true` flag
+ * and the presence of `children`.
+ */
+export interface CombinatorMarkIR extends BaseIRNode {
+    type: CombinatorMarkType;
+    __combinator: true;
+    options?: Record<string, unknown>;
+    children: MarkIR[];
+    name?: string;
+    label?: LabelIR;
+    constraints?: ConstraintIR[];
+    zOrder?: number;
+}
+/** A by-name reference to another named mark (`ref("bars")`). */
+export interface RefMarkIR extends BaseIRNode {
+    type: "ref";
+    selection: string | Array<string | number>;
+    name?: string;
+    label?: LabelIR;
+    zOrder?: number;
+}
+/**
+ * A channel value (the right-hand side of a mark or operator property like
+ * `h: …` or `fill: …`).
+ *
+ * Strings without explicit tagging disambiguate to field-accessor or
+ * literal at runtime by checking against `data[0]`. The explicit
+ * constructors `field(name)` / `datum(x)` / `literal(x)` emit their
+ * canonical tagged-object forms. `__gofish_lambda` is the one remaining
+ * Python-bridge sentinel — it encodes a remote callable that the widget
+ * resolves via the DeriveBridge.
+ *
+ * v0.1+ will move the v3 API to desugar string shorthand to explicit
+ * constructors eagerly, so the IR carries only canonical forms.
+ */
+export type ChannelValue = string | number | boolean | null | DatumValue | BridgeLambdaSentinel;
+export interface DatumValue {
+    type: "datum";
+    [key: string]: unknown;
+}
+/** Python-bridge sentinel for a remote callable. The JS side issues an RPC for each datum. */
+export interface BridgeLambdaSentinel {
+    __gofish_lambda: string;
+}
+/**
+ * Label specification.
+ *
+ * The canonical object form `{accessor, position?, fontSize?, ...}` is
+ * what `mark.label("field", options)` produces. Shorthand forms (matching
+ * the JS mark-kwarg API):
+ *
+ *   label: true     — show a label with default styling
+ *   label: "field"  — label using this field accessor, defaults elsewhere
+ */
+export type LabelIR = true | string | {
+    accessor: string;
+    position?: string;
+    fontSize?: number;
+    color?: string;
+    offset?: number;
+    minSpace?: number;
+    rotate?: number;
+};
+export interface ConstraintIR {
+    type: "align" | "distribute" | "zAbove" | "zBelow";
+    /** Positioning constraints carry `options`; z-order constraints don't. */
+    options?: Record<string, unknown>;
+    refs: string[];
+}
+/** Discriminate a root document. */
+export declare function isChartIR(node: FrontendIR): node is ChartIR;
+export declare function isLayerIR(node: FrontendIR): node is LayerIR;
+export declare function isRawMarkIR(node: FrontendIR): node is RawMarkIR;
+/** Discriminate a mark by family. */
+export declare function isCombinatorMarkIR(mark: MarkIR): mark is CombinatorMarkIR;
+export declare function isRefMarkIR(mark: MarkIR): mark is RefMarkIR;
+export declare function isLeafMarkIR(mark: MarkIR): mark is LeafMarkIR;
+/** The set of operator type discriminators recognized in v0. */
+export declare const OPERATOR_TYPES: readonly ["derive", "spread", "stack", "group", "scatter", "table", "log"];
+/** The set of leaf-mark type discriminators recognized in v0. */
+export declare const LEAF_MARK_TYPES: readonly LeafMarkType[];
+/** The set of combinator-mark type discriminators recognized in v0. */
+export declare const COMBINATOR_MARK_TYPES: readonly CombinatorMarkType[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/frontend/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/frontend/schema.ts"],"names":[],"mappings":"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"}

package/dist/frontend/schema.js

@@ -0,0 +1,69 @@
+// <gofish-wiki> AUTO-GENERATED — see covers: in the essay; run `pnpm --filter docs sync-backlinks`
+// @wiki Frontend IR — /internals/frontend/serialization
+// </gofish-wiki>
+// ---------------------------------------------------------------------------
+// Discriminator helpers (predicates)
+// ---------------------------------------------------------------------------
+/** Discriminate a root document. */
+export function isChartIR(node) {
+    return node.type === "chart";
+}
+export function isLayerIR(node) {
+    return node.type === "layer";
+}
+export function isRawMarkIR(node) {
+    return node.type === "raw-mark";
+}
+/** Discriminate a mark by family. */
+export function isCombinatorMarkIR(mark) {
+    return (mark.__combinator === true &&
+        Array.isArray(mark.children));
+}
+export function isRefMarkIR(mark) {
+    return mark.type === "ref";
+}
+export function isLeafMarkIR(mark) {
+    return !isCombinatorMarkIR(mark) && !isRefMarkIR(mark);
+}
+/** The set of operator type discriminators recognized in v0. */
+export const OPERATOR_TYPES = [
+    "derive",
+    "spread",
+    "stack",
+    "group",
+    "scatter",
+    "table",
+    "log",
+];
+/** The set of leaf-mark type discriminators recognized in v0. */
+export const LEAF_MARK_TYPES = [
+    "rect",
+    "circle",
+    "line",
+    "area",
+    "blank",
+    "ellipse",
+    "petal",
+    "text",
+    "image",
+    "polygon",
+    "mark-fn",
+];
+/** The set of combinator-mark type discriminators recognized in v0. */
+export const COMBINATOR_MARK_TYPES = [
+    "spread",
+    "stack",
+    "scatter",
+    "group",
+    "table",
+    "layer",
+    "arrow",
+    "connect",
+    "treemap",
+    "over",
+    "inside",
+    "xor",
+    "out",
+    "atop",
+    "mask",
+];