@astrale-os/kernel-core 0.9.0-beta.63 → 0.9.0-beta.65

package/dist/schema/kernel/projection/path.js

@@ -1,113 +0,0 @@
-import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
-import { GraphPathAmbiguousError } from '#graph/graph';
-import { K } from '../index.js';
-export const projectionPathWalker = Object.freeze({
-    walk: walkProjectionPath,
-});
-function walkProjectionPath(path, context) {
-    let candidates = anchorCandidates(path.ast, context);
-    for (const step of path.ast.steps)
-        candidates = applyStep(candidates, step, context);
-    if (candidates.length === 0)
-        return undefined;
-    if (candidates.length === 1)
-        return candidates[0];
-    throw new GraphPathAmbiguousError(path.raw, candidates.length);
-}
-function anchorCandidates(ast, context) {
-    if (ast.anchor.kind === 'id') {
-        const node = context.nodes.byId(ast.anchor.id);
-        return node === undefined ? [] : [node];
-    }
-    const domainClass = ClassKey.of(K.classes.Domain.ref);
-    const origin = ast.anchor.origin;
-    return context.nodes
-        .byClass(domainClass)
-        .filter((node) => node.props[K.classes.Domain.properties.origin.key] === origin);
-}
-function applyStep(current, step, context) {
-    switch (step.kind) {
-        case 'projection':
-            return domainMembers(current, `${step.projection.kind}.${step.projection.name}`, context);
-        case 'method':
-            return step.dispatch === 'static'
-                ? directMethods(current, step.name, true, context)
-                : instanceMethods(current.filter((node) => node.class === step.class), step.name, context);
-        case 'traverse':
-            return traverse(current, step, context);
-    }
-}
-function domainMembers(domains, member, context) {
-    const domainIds = new Set(domains.map((node) => node.id));
-    return distinctNodes(edgesOf(K.classes.of_domain, context).flatMap((edge) => {
-        if (!domainIds.has(edge.target) ||
-            edge.props[K.classes.of_domain.properties.member.key] !== member) {
-            return [];
-        }
-        const node = context.nodes.byId(edge.source);
-        return node === undefined ? [] : [node];
-    }));
-}
-function directMethods(owners, name, isStatic, context) {
-    const ownerIds = new Set(owners.map((node) => node.id));
-    return distinctNodes(edgesOf(K.classes.method_of, context).flatMap((edge) => {
-        if (!ownerIds.has(edge.target) ||
-            edge.props[K.classes.method_of.properties.name.key] !== name ||
-            edge.props[K.classes.method_of.properties.static.key] !== isStatic) {
-            return [];
-        }
-        const method = context.nodes.byId(edge.source);
-        return method === undefined ? [] : [method];
-    }));
-}
-function instanceMethods(instances, name, context) {
-    return distinctNodes(instances.flatMap((instance) => {
-        const owner = resolveClassProjection(instance.class, context);
-        return owner.length === 0 ? [] : directMethods(owner, name, false, context);
-    }));
-}
-function resolveClassProjection(key, context) {
-    const domainClass = ClassKey.of(K.classes.Domain.ref);
-    const domains = context.nodes
-        .byClass(domainClass)
-        .filter((node) => node.props[K.classes.Domain.properties.origin.key] === ClassKey.ref(key).origin);
-    return domainMembers(domains, `class.${ClassKey.ref(key).name}`, context);
-}
-function traverse(current, step, context) {
-    const currentIds = new Set(current.map((node) => node.id));
-    const edgeClass = step.class;
-    const orientation = context.orientation(edgeClass);
-    const candidates = context.edges.byClass(edgeClass);
-    return distinctNodes(candidates.flatMap((edge) => {
-        if (step.slug !== undefined && edge.slug !== step.slug)
-            return [];
-        const endpoint = traversedEndpoint(edge, currentIds, step.direction, orientation);
-        if (endpoint === undefined)
-            return [];
-        const node = context.nodes.byId(endpoint);
-        return node === undefined ? [] : [node];
-    }));
-}
-function traversedEndpoint(edge, current, direction, orientation) {
-    if (orientation === 'undirected') {
-        if (current.has(edge.source))
-            return edge.target;
-        if (current.has(edge.target))
-            return edge.source;
-        return undefined;
-    }
-    if (direction === 'out' && current.has(edge.source))
-        return edge.target;
-    if (direction === 'in' && current.has(edge.target))
-        return edge.source;
-    return undefined;
-}
-function edgesOf(relation, context) {
-    return context.edges.byClass(ClassKey.of(relation.ref));
-}
-function distinctNodes(nodes) {
-    const byId = new Map();
-    for (const node of nodes)
-        byId.set(node.id, node);
-    return [...byId.values()];
-}