@woosh/meep-engine 3.15.0 → 3.16.0

package/src/shade/renderer/particles/graph/particle_graph_json.js

@@ -0,0 +1,196 @@
+import { NodeInstance } from "../../../../core/model/node-graph/node/NodeInstance.js";
+import {
+    get_particle_library_description,
+    particle_library_description_or_undefined,
+} from "./particle_node_library.js";
+import { particle_node_default_parameters } from "./particle_node_parameters.js";
+import { is_particle_group_description } from "./ParticleNodeGroup.js";
+
+/**
+ * Read and write a particle {@link NodeGraph} as JSON.
+ *
+ * The engine's generic graph serializer writes each {@link NodeDescription} out by value. That
+ * cannot work here: a {@link ./ParticleNodeDescription.js} carries an `emit` closure, which is the
+ * whole of what the node *is*, and no amount of JSON brings a closure back. So a particle node is
+ * written as its **type name** and looked up in the library on the way in — the same thing authoring
+ * does, and the reason node type names, not ids, are the stable identity of the library.
+ *
+ * Ports are written by name for the same reason. A particle node's ports are uniquely named within
+ * a direction, so a name survives the library gaining a port where a positional id would not.
+ *
+ * Node positions ride along when a {@link NodeGraphVisualData} is supplied. An effect whose layout
+ * is not saved with it is an effect that has to be re-arranged every time it is opened, so they
+ * belong in the same document even though one is model and the other is presentation.
+ */
+
+/**
+ * @typedef {object} ParticleGraphJSON
+ * @property {Array<{id: number, type: string, parameters: object, x?: number, y?: number}>} nodes
+ * @property {Array<{from: number, fromPort: string, to: number, toPort: string}>} connections
+ */
+
+/**
+ * @param {object} params
+ * @param {NodeGraph} params.graph
+ * @param {NodeGraphVisualData} [params.visual] source of node positions; omitted, no positions are written
+ * @returns {ParticleGraphJSON}
+ */
+export function serialize_particle_graph({ graph, visual }) {
+    const nodes = graph.getNodes().map(node => {
+        const record = {
+            id: node.id,
+            type: node.description.name,
+            // a shallow copy: parameter values are numbers, strings and arrays of numbers
+            parameters: structuredClone(node.parameters),
+        };
+
+        const node_visual = visual === undefined ? undefined : visual.getNode(node.id);
+
+        if (node_visual !== undefined) {
+            record.x = node_visual.dimensions.position.x;
+            record.y = node_visual.dimensions.position.y;
+        }
+
+        return record;
+    });
+
+    const connections = [];
+
+    graph.traverseConnections(connection => {
+        connections.push({
+            from: connection.source.instance.id,
+            fromPort: connection.source.port.name,
+            to: connection.target.instance.id,
+            toPort: connection.target.port.name,
+        });
+    });
+
+    return { nodes, connections };
+}
+
+/**
+ * Fill a graph from JSON, replacing whatever it held.
+ *
+ * Node ids are preserved exactly, holes and all: an author who deleted a node left a gap in the
+ * numbering, and everything written alongside — connections, positions — is written against the ids
+ * that survived it.
+ *
+ * @param {object} params
+ * @param {ParticleGraphJSON} params.json
+ * @param {NodeGraph} params.graph filled in place
+ * @param {NodeGraphVisualData} [params.visual] receives the saved positions
+ * @param {NodeDescriptionVisualRegistry} [params.visualRegistry] required when `visual` is given
+ * @param {function(string):(ParticleNodeDescription|undefined)} [params.resolve] types this document
+ *        carries of its own — the groups an author made — consulted before the standard library. A
+ *        group is addressed by name exactly as a stock type is, and one that lives in the file
+ *        rather than in the library has to be found somewhere.
+ * @returns {NodeGraph} `graph`
+ */
+export function deserialize_particle_graph({ json, graph, visual, visualRegistry, resolve }) {
+    graph.reset();
+
+    if (visual !== undefined) {
+        for (const id of Array.from(visual.nodes.keys())) {
+            visual.removeNode(id);
+        }
+    }
+
+    for (const record of json.nodes ?? []) {
+        const description = resolve?.(record.type) ?? get_particle_library_description(record.type);
+
+        if (!Number.isInteger(record.id) || record.id < 0) {
+            throw new Error(`Particle graph node id must be a non-negative integer, got ${record.id}`);
+        }
+
+        // The saved id is claimed rather than a fresh one taken: an author who deleted a node left a
+        // hole in the numbering, and the connections and positions saved alongside are written
+        // against the ids that survived it.
+        const node = new NodeInstance();
+
+        node.id = record.id;
+        node.setDescription(description);
+
+        // A parameter the file does not carry takes the type's default, which is how a node type
+        // gains a parameter without every effect saved before it gaining an error: a `random`
+        // written before it had a width is read as four lanes, which is the width it was. A group
+        // declares none — its configuration is the wiring inside it — and has no defaults to ask for.
+        const defaults = is_particle_group_description(description)
+            ? {}
+            : particle_node_default_parameters(record.type);
+
+        node.setParameters({ ...defaults, ...(record.parameters ?? {}) });
+
+        graph.addNode(node);
+
+        if (visual !== undefined && visualRegistry !== undefined) {
+            const node_visual = visual.ensureNode(node, visualRegistry);
+
+            if (record.x !== undefined && record.y !== undefined) {
+                node_visual.dimensions.position.set(record.x, record.y);
+            }
+        }
+    }
+
+    for (const record of json.connections ?? []) {
+        graph.createConnectionByPortName(record.from, record.fromPort, record.to, record.toPort);
+    }
+
+    return graph;
+}
+
+/**
+ * Whether a graph can be written and read back — every node a particle node whose type the library
+ * still has, and every type's ports uniquely named within a direction so a connection can be
+ * written by name. Used to fail an export with something an author can act on rather than at the
+ * far end of a load.
+ *
+ * @param {NodeGraph} graph
+ * @param {object} [options]
+ * @param {function(string):(ParticleNodeDescription|undefined)} [options.resolve] the document's own
+ *        types, as in {@link deserialize_particle_graph}
+ * @returns {string[]} one message per problem; empty when the graph is serializable
+ */
+export function particle_graph_serialization_problems(graph, { resolve } = {}) {
+    const problems = [];
+
+    /** @type {Set<ParticleNodeDescription>} types already checked, so one is reported once */
+    const seen = new Set();
+
+    for (const node of graph.getNodes()) {
+        const description = node.description;
+
+        if (description?.isParticleNodeDescription !== true) {
+            problems.push(`Node ${node.id} is not a particle node.`);
+            continue;
+        }
+
+        const known = resolve?.(description.name) ?? particle_library_description_or_undefined(description.name);
+
+        if (known !== description) {
+            problems.push(`Node ${node.id} is a '${description.name}' from outside the standard library.`);
+        }
+
+        if (seen.has(description)) {
+            continue;
+        }
+
+        seen.add(description);
+
+        const claimed = new Set();
+
+        for (const port of description.getPorts()) {
+            const key = `${port.direction}/${port.name}`;
+
+            if (claimed.has(key)) {
+                problems.push(
+                    `Node type '${description.name}' has more than one port named '${port.name}' in one `
+                    + `direction, so connections to it cannot be written by name.`
+                );
+            }
+
+            claimed.add(key);
+        }
+    }
+
+    return problems;
+}

package/src/shade/renderer/particles/graph/particle_group_json.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @typedef {object} ParticleGroupJSON
+ * @property {string} name
+ * @property {string} label
+ * @property {string} icon
+ * @property {string} help
+ * @property {Array<{name: string, type: string|null}>} inputs
+ * @property {Array<{name: string, type: string|null}>} outputs
+ * @property {import("./particle_graph_json.js").ParticleGraphJSON} body
+ */
+/**
+ * @param {import("./ParticleNodeGroup.js").ParticleNodeGroup} group
+ * @returns {ParticleGroupJSON}
+ */
+export function serialize_particle_group(group: import("./ParticleNodeGroup.js").ParticleNodeGroup): ParticleGroupJSON;
+/**
+ * Build a group from what was written down.
+ *
+ * @param {object} params
+ * @param {ParticleGroupJSON} params.json
+ * @param {NodeDescriptionVisualRegistry} [params.visualRegistry] receives a box for the group's own
+ *        three node types, and is where the body's nodes get theirs from
+ * @param {function(string):(ParticleNodeDescription|undefined)} [params.resolve] the document's other
+ *        groups, for a body that uses one
+ * @returns {import("./ParticleNodeGroup.js").ParticleNodeGroup}
+ */
+export function deserialize_particle_group({ json, visualRegistry, resolve }: {
+    json: ParticleGroupJSON;
+    visualRegistry?: NodeDescriptionVisualRegistry;
+    resolve?: (arg0: string) => (ParticleNodeDescription | undefined);
+}): import("./ParticleNodeGroup.js").ParticleNodeGroup;
+/**
+ * Every node type a group brings with it: the one an author places, and its two boundary blocks.
+ *
+ * What a visual registry has to be told about before anything of the group can be drawn.
+ *
+ * @param {import("./ParticleNodeGroup.js").ParticleNodeGroup} group
+ * @returns {import("./ParticleNodeDescription.js").ParticleNodeDescription[]}
+ */
+export function particle_group_descriptions(group: import("./ParticleNodeGroup.js").ParticleNodeGroup): import("./ParticleNodeDescription.js").ParticleNodeDescription[];
+/**
+ * Read and write a {@link ./ParticleNodeGroup.js group definition} as JSON.
+ *
+ * A group an author makes belongs to the document they made it in. The library's own groups are code
+ * and are looked up by name; one of these is a thing in a file, and the file has to carry the whole
+ * of it — the face it presents, and the body behind it.
+ *
+ * ## The boundary blocks
+ *
+ * A group's two boundary blocks are node types built for that one group, so a body written out names
+ * them after the group. That would make the group's *name* part of its body, which it must not be: a
+ * group loaded under a different name — because the one it had was taken — would then not find its
+ * own edge. So the two are written under fixed names instead, and read back as whatever blocks the
+ * group being loaded has.
+ *
+ * ## Locked
+ *
+ * Nothing here is locked. Locked means "this body is the library's and is shared by every effect",
+ * and a body in a document is by definition neither. A file that claims otherwise is read as
+ * unlocked rather than believed.
+ */
+/**
+ * What the input block is written down as, whatever the group ends up being called.
+ * @type {string}
+ */
+export const PARTICLE_GROUP_INPUT_TYPE: string;
+/**
+ * @type {string}
+ */
+export const PARTICLE_GROUP_OUTPUT_TYPE: string;
+export type ParticleGroupJSON = {
+    name: string;
+    label: string;
+    icon: string;
+    help: string;
+    inputs: Array<{
+        name: string;
+        type: string | null;
+    }>;
+    outputs: Array<{
+        name: string;
+        type: string | null;
+    }>;
+    body: import("./particle_graph_json.js").ParticleGraphJSON;
+};
+//# sourceMappingURL=particle_group_json.d.ts.map

package/src/shade/renderer/particles/graph/particle_group_json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particle_group_json.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_group_json.js"],"names":[],"mappings":"AA+CA;;;;;;;;;GASG;AAEH;;;GAGG;AACH,gDAHW,OAAO,wBAAwB,EAAE,iBAAiB,GAChD,iBAAiB,CAmC7B;AAED;;;;;;;;;;GAUG;AACH;IAPqC,IAAI,EAA9B,iBAAiB;IACsB,cAAc;IAES,OAAO,UAA5D,MAAM,KAAE,CAAC,0BAAwB,SAAS,CAAC;IAElD,OAAO,wBAAwB,EAAE,iBAAiB,CAiD9D;AAED;;;;;;;GAOG;AACH,mDAHW,OAAO,wBAAwB,EAAE,iBAAiB,GAChD,OAAO,8BAA8B,EAAE,uBAAuB,EAAE,CAI5E;AA9JD;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;GAGG;AACH,wCAFU,MAAM,CAEwC;AAExD;;GAEG;AACH,yCAFU,MAAM,CAE0C;;UAS5C,MAAM;WACN,MAAM;UACN,MAAM;UACN,MAAM;YACN,MAAM;QAAC,MAAM,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,GAAC,IAAI,CAAA;KAAC,CAAC;aACxC,MAAM;QAAC,MAAM,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,GAAC,IAAI,CAAA;KAAC,CAAC;UACxC,OAAO,0BAA0B,EAAE,iBAAiB"}

package/src/shade/renderer/particles/graph/particle_group_json.js

@@ -0,0 +1,182 @@
+import {
+    deserialize_particle_graph,
+    serialize_particle_graph,
+} from "./particle_graph_json.js";
+import { is_particle_group_boundary, ParticleNodeGroup } from "./ParticleNodeGroup.js";
+import {
+    PARTICLE_ALL_VALUE_TYPES,
+} from "./ParticleValueType.js";
+
+/**
+ * Read and write a {@link ./ParticleNodeGroup.js group definition} as JSON.
+ *
+ * A group an author makes belongs to the document they made it in. The library's own groups are code
+ * and are looked up by name; one of these is a thing in a file, and the file has to carry the whole
+ * of it — the face it presents, and the body behind it.
+ *
+ * ## The boundary blocks
+ *
+ * A group's two boundary blocks are node types built for that one group, so a body written out names
+ * them after the group. That would make the group's *name* part of its body, which it must not be: a
+ * group loaded under a different name — because the one it had was taken — would then not find its
+ * own edge. So the two are written under fixed names instead, and read back as whatever blocks the
+ * group being loaded has.
+ *
+ * ## Locked
+ *
+ * Nothing here is locked. Locked means "this body is the library's and is shared by every effect",
+ * and a body in a document is by definition neither. A file that claims otherwise is read as
+ * unlocked rather than believed.
+ */
+
+/**
+ * What the input block is written down as, whatever the group ends up being called.
+ * @type {string}
+ */
+export const PARTICLE_GROUP_INPUT_TYPE = "@group/input";
+
+/**
+ * @type {string}
+ */
+export const PARTICLE_GROUP_OUTPUT_TYPE = "@group/output";
+
+/**
+ * @type {Map<string, import("./ParticleValueType.js").ParticleValueType>}
+ */
+const TYPES_BY_NAME = new Map(PARTICLE_ALL_VALUE_TYPES.map(type => [type.name, type]));
+
+/**
+ * @typedef {object} ParticleGroupJSON
+ * @property {string} name
+ * @property {string} label
+ * @property {string} icon
+ * @property {string} help
+ * @property {Array<{name: string, type: string|null}>} inputs
+ * @property {Array<{name: string, type: string|null}>} outputs
+ * @property {import("./particle_graph_json.js").ParticleGraphJSON} body
+ */
+
+/**
+ * @param {import("./ParticleNodeGroup.js").ParticleNodeGroup} group
+ * @returns {ParticleGroupJSON}
+ */
+export function serialize_particle_group(group) {
+    const body = serialize_particle_graph({ graph: group.graph, visual: group.visual });
+
+    /** @type {Map<number, string>} node id -> the fixed name its boundary block is written under */
+    const boundaries = new Map();
+
+    for (const node of group.graph.getNodes()) {
+        if (!is_particle_group_boundary(node)) {
+            continue;
+        }
+
+        boundaries.set(node.id, node.description.side === "input"
+            ? PARTICLE_GROUP_INPUT_TYPE
+            : PARTICLE_GROUP_OUTPUT_TYPE);
+    }
+
+    for (const record of body.nodes) {
+        const fixed = boundaries.get(record.id);
+
+        if (fixed !== undefined) {
+            record.type = fixed;
+        }
+    }
+
+    return {
+        name: group.name,
+        label: group.label,
+        icon: group.icon,
+        help: group.help,
+        inputs: group.inputs.map(port => ({ name: port.name, type: port.type?.name ?? null })),
+        outputs: group.outputs.map(port => ({ name: port.name, type: port.type?.name ?? null })),
+        body,
+    };
+}
+
+/**
+ * Build a group from what was written down.
+ *
+ * @param {object} params
+ * @param {ParticleGroupJSON} params.json
+ * @param {NodeDescriptionVisualRegistry} [params.visualRegistry] receives a box for the group's own
+ *        three node types, and is where the body's nodes get theirs from
+ * @param {function(string):(ParticleNodeDescription|undefined)} [params.resolve] the document's other
+ *        groups, for a body that uses one
+ * @returns {import("./ParticleNodeGroup.js").ParticleNodeGroup}
+ */
+export function deserialize_particle_group({ json, visualRegistry, resolve }) {
+    const group = ParticleNodeGroup.create({
+        name: json.name,
+        label: json.label ?? "",
+        icon: json.icon ?? "",
+        help: json.help ?? "",
+        // see the note at the top: a document's group is the author's, always
+        locked: false,
+        inputs: (json.inputs ?? []).map(port => ({ name: port.name, type: value_type(port.type) })),
+        outputs: (json.outputs ?? []).map(port => ({ name: port.name, type: value_type(port.type) })),
+    });
+
+    if (visualRegistry !== undefined) {
+        for (const description of particle_group_descriptions(group)) {
+            visualRegistry.generate(description);
+        }
+    }
+
+    const blocks = new Map([
+        [PARTICLE_GROUP_INPUT_TYPE, group.inputNode.description],
+        [PARTICLE_GROUP_OUTPUT_TYPE, group.outputNode.description],
+    ]);
+
+    deserialize_particle_graph({
+        json: json.body ?? { nodes: [], connections: [] },
+        graph: group.graph,
+        visual: group.visual,
+        visualRegistry,
+        resolve: name => blocks.get(name) ?? resolve?.(name),
+    });
+
+    // Loading replaced every node in the body, the two blocks included, so the group's handles on its
+    // own edge point at instances that are no longer in it. Flattening finds a boundary by identity,
+    // which is what makes this a repair rather than a tidy-up.
+    for (const node of group.graph.getNodes()) {
+        if (!is_particle_group_boundary(node)) {
+            continue;
+        }
+
+        if (node.description.side === "input") {
+            group.inputNode = node;
+        } else {
+            group.outputNode = node;
+        }
+    }
+
+    return group;
+}
+
+/**
+ * Every node type a group brings with it: the one an author places, and its two boundary blocks.
+ *
+ * What a visual registry has to be told about before anything of the group can be drawn.
+ *
+ * @param {import("./ParticleNodeGroup.js").ParticleNodeGroup} group
+ * @returns {import("./ParticleNodeDescription.js").ParticleNodeDescription[]}
+ */
+export function particle_group_descriptions(group) {
+    return [group.description, group.inputNode.description, group.outputNode.description];
+}
+
+/**
+ * @param {string|null|undefined} name
+ * @returns {import("./ParticleValueType.js").ParticleValueType|null} the type, or `null` for a port
+ *   that takes the shape of what arrives — which is also what an unrecognised name reads as, since a
+ *   file naming a type this build has never heard of is better opened than refused
+ */
+function value_type(name) {
+    if (typeof name !== "string") {
+        return null;
+    }
+
+    return TYPES_BY_NAME.get(name) ?? null;
+}

package/src/shade/renderer/particles/graph/particle_group_library.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Add a group to the library.
+ *
+ * A group's body may only wire up groups that are already registered, which is what makes the
+ * reference graph acyclic and so makes flattening terminate — see
+ * {@link ./flatten_particle_graph.js}. That falls out of building them in order and is not enforced
+ * here; what is enforced is that a name is claimed once.
+ *
+ * @param {import("./ParticleNodeGroup.js").ParticleNodeGroup} group
+ * @returns {import("./ParticleNodeGroup.js").ParticleNodeGroup} `group`
+ */
+export function register_particle_group(group: import("./ParticleNodeGroup.js").ParticleNodeGroup): import("./ParticleNodeGroup.js").ParticleNodeGroup;
+/**
+ * Every registered group, in registration order.
+ *
+ * @returns {import("./ParticleNodeGroup.js").ParticleNodeGroup[]}
+ */
+export function particle_groups(): import("./ParticleNodeGroup.js").ParticleNodeGroup[];
+/**
+ * Look a group up by name.
+ *
+ * @param {string} name
+ * @returns {import("./ParticleNodeGroup.js").ParticleNodeGroup|undefined}
+ */
+export function get_particle_group(name: string): import("./ParticleNodeGroup.js").ParticleNodeGroup | undefined;
+/**
+ * Whether a name belongs to a group rather than a stock node type.
+ *
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function is_particle_group_name(name: string): boolean;
+//# sourceMappingURL=particle_group_library.d.ts.map

package/src/shade/renderer/particles/graph/particle_group_library.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particle_group_library.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_group_library.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;GAUG;AACH,+CAHW,OAAO,wBAAwB,EAAE,iBAAiB,GAChD,OAAO,wBAAwB,EAAE,iBAAiB,CAgB9D;AAED;;;;GAIG;AACH,mCAFa,OAAO,wBAAwB,EAAE,iBAAiB,EAAE,CAIhE;AAED;;;;;GAKG;AACH,yCAHW,MAAM,GACJ,OAAO,wBAAwB,EAAE,iBAAiB,GAAC,SAAS,CAIxE;AAED;;;;;GAKG;AACH,6CAHW,MAAM,GACJ,OAAO,CAInB"}

package/src/shade/renderer/particles/graph/particle_group_library.js

@@ -0,0 +1,75 @@
+import { PARTICLE_NODE_REGISTRY } from "./ParticleNodeRegistry.js";
+
+/**
+ * Every {@link ./ParticleNodeGroup.js node group} the library knows about, by name.
+ *
+ * Separate from the stock library's own `descriptions_by_name` on purpose. A stock type's identity
+ * is its position in {@link ./ParticleNodeRegistry.js} — the ids there are a wire format — while a
+ * group is a thing built at load time out of stock types, and could in principle be built by a host
+ * or read out of a document. Keeping the two apart means adding a group can never renumber a node
+ * type, and lets `particle_node_parameters.spec.js` keep asserting that every *stock* type declares
+ * its parameters without a group having to pretend it has some.
+ *
+ * The node descriptions themselves do go into the shared {@link PARTICLE_NODE_REGISTRY}, because
+ * that is what an editor generates node boxes from, and a group node has to be drawable like any
+ * other.
+ *
+ * @type {Map<string, import("./ParticleNodeGroup.js").ParticleNodeGroup>}
+ */
+const groups_by_name = new Map();
+
+/**
+ * Add a group to the library.
+ *
+ * A group's body may only wire up groups that are already registered, which is what makes the
+ * reference graph acyclic and so makes flattening terminate — see
+ * {@link ./flatten_particle_graph.js}. That falls out of building them in order and is not enforced
+ * here; what is enforced is that a name is claimed once.
+ *
+ * @param {import("./ParticleNodeGroup.js").ParticleNodeGroup} group
+ * @returns {import("./ParticleNodeGroup.js").ParticleNodeGroup} `group`
+ */
+export function register_particle_group(group) {
+    if (groups_by_name.has(group.name)) {
+        throw new Error(`Duplicate particle node group '${group.name}'`);
+    }
+
+    groups_by_name.set(group.name, group);
+
+    // The group node itself, and the two boundary blocks its body is wired to: a view that opens the
+    // group draws those, and everything drawn needs a box generated for it.
+    PARTICLE_NODE_REGISTRY.addNode(group.description);
+    PARTICLE_NODE_REGISTRY.addNode(group.inputNode.description);
+    PARTICLE_NODE_REGISTRY.addNode(group.outputNode.description);
+
+    return group;
+}
+
+/**
+ * Every registered group, in registration order.
+ *
+ * @returns {import("./ParticleNodeGroup.js").ParticleNodeGroup[]}
+ */
+export function particle_groups() {
+    return Array.from(groups_by_name.values());
+}
+
+/**
+ * Look a group up by name.
+ *
+ * @param {string} name
+ * @returns {import("./ParticleNodeGroup.js").ParticleNodeGroup|undefined}
+ */
+export function get_particle_group(name) {
+    return groups_by_name.get(name);
+}
+
+/**
+ * Whether a name belongs to a group rather than a stock node type.
+ *
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function is_particle_group_name(name) {
+    return groups_by_name.has(name);
+}

package/src/shade/renderer/particles/graph/particle_node_library.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The whole node library an author picks from: the stock types, and the
+ * {@link ./ParticleNodeGroup.js groups} built out of them.
+ *
+ * One accessor rather than two because a library with the groups missing is a library that cannot
+ * open half the effects saved with it — a group is addressed by name in a document exactly as a
+ * stock type is, and a loader that only knew about the stock ones would refuse a file it wrote
+ * itself. Importing this is what guarantees the built-in groups have been registered; nothing else
+ * should reach for `groups/particle_builtin_groups.js` directly.
+ *
+ * The two halves stay separate underneath. A stock type's id is its position in
+ * {@link ./ParticleNodeRegistry.js} and that is a wire format; a group is built at load time out of
+ * stock types and has no such position to lose. Keeping them apart is what lets a group be added
+ * without renumbering a node type.
+ */
+/**
+ * Every type an author can place, stock types first and then the groups.
+ *
+ * @returns {import("./ParticleNodeDescription.js").ParticleNodeDescription[]}
+ */
+export function particle_library_descriptions(): import("./ParticleNodeDescription.js").ParticleNodeDescription[];
+/**
+ * Look a type up by the name a document holds.
+ *
+ * @param {string} name
+ * @returns {import("./ParticleNodeDescription.js").ParticleNodeDescription}
+ * @throws if the library has no such type
+ */
+export function get_particle_library_description(name: string): import("./ParticleNodeDescription.js").ParticleNodeDescription;
+/**
+ * The same lookup, for a caller that has something to say about a missing type itself.
+ *
+ * @param {string} name
+ * @returns {import("./ParticleNodeDescription.js").ParticleNodeDescription|undefined}
+ */
+export function particle_library_description_or_undefined(name: string): import("./ParticleNodeDescription.js").ParticleNodeDescription | undefined;
+//# sourceMappingURL=particle_node_library.d.ts.map

package/src/shade/renderer/particles/graph/particle_node_library.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particle_node_library.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_node_library.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AAEH;;;;GAIG;AACH,iDAFa,OAAO,8BAA8B,EAAE,uBAAuB,EAAE,CAO5E;AAED;;;;;;GAMG;AACH,uDAJW,MAAM,GACJ,OAAO,8BAA8B,EAAE,uBAAuB,CAW1E;AAED;;;;;GAKG;AACH,gEAHW,MAAM,GACJ,OAAO,8BAA8B,EAAE,uBAAuB,GAAC,SAAS,CAUpF"}