@terra-graph/core 1.0.0-rc.4

package/dist/esm/Graph/GraphPlugin.js

@@ -0,0 +1,217 @@
+import { NamedRuleRegistry } from './Rules/NamedRuleRegistry.js';
+import { NamedRuleSetRegistry, } from './Rules/NamedRuleSetRegistry.js';
+import { isNamedPhase, isNamedRuleRef, isNamedRuleSetRef, } from './Rules/RulePlan.js';
+import { RuleSet } from './Rules/RuleSet.js';
+export class GraphPlugin {
+    name;
+    defaults;
+    constructor(name, defaults) {
+        this.name = name;
+        this.defaults = defaults;
+    }
+}
+export class GraphPluginRegistry {
+    definitions;
+    constructor(definitions = {}, factories) {
+        this.definitions = Object.freeze(factories ?? GraphPluginRegistry.toFactories(definitions));
+    }
+    static from(registries) {
+        return registries.reduce((combined, registry) => combined.use(registry), new GraphPluginRegistry());
+    }
+    register(name, definition) {
+        return GraphPluginRegistry.fromFactories({
+            ...this.definitions,
+            [name]: GraphPluginRegistry.toFactory(definition),
+        });
+    }
+    registerMany(definitions) {
+        const nextFactories = {
+            ...this.definitions,
+            ...GraphPluginRegistry.toFactories(definitions),
+        };
+        return GraphPluginRegistry.fromFactories(nextFactories);
+    }
+    use(registry) {
+        return GraphPluginRegistry.fromFactories({
+            ...this.definitions,
+            ...registry.definitions,
+        });
+    }
+    resolve(name) {
+        const factory = this.definitions[name];
+        if (!factory) {
+            throw new Error(`GraphPlugin '${name}' is not registered`);
+        }
+        const plugin = factory();
+        if (plugin.name !== name) {
+            throw new Error(`GraphPlugin registry key '${name}' does not match plugin.name '${plugin.name}'`);
+        }
+        return plugin;
+    }
+    names() {
+        return Object.keys(this.definitions);
+    }
+    static fromFactories(definitions) {
+        return new GraphPluginRegistry({}, { ...definitions });
+    }
+    static toFactories(definitions) {
+        return Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [
+            name,
+            GraphPluginRegistry.toFactory(definition),
+        ]));
+    }
+    static toFactory(definition) {
+        if (typeof definition === 'function') {
+            return definition;
+        }
+        return () => definition;
+    }
+}
+const isObjectRecord = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+const resolveGraphPluginOptions = (plugin, options) => {
+    if (options === undefined) {
+        if (isObjectRecord(plugin.defaults)) {
+            return { ...plugin.defaults };
+        }
+        if (plugin.defaults !== undefined) {
+            return plugin.defaults;
+        }
+        return {};
+    }
+    if (isObjectRecord(plugin.defaults) && isObjectRecord(options)) {
+        return {
+            ...plugin.defaults,
+            ...options,
+        };
+    }
+    return options;
+};
+const toPrefixedName = (pluginName, localName) => {
+    const prefix = `${pluginName}.`;
+    if (localName.startsWith(prefix)) {
+        return localName;
+    }
+    return `${prefix}${localName}`;
+};
+const createPrefixedNameMap = (pluginName, localNames, kind) => {
+    const nameMap = new Map();
+    const prefixed = new Set();
+    for (const localName of localNames) {
+        const resolvedName = toPrefixedName(pluginName, localName);
+        if (prefixed.has(resolvedName)) {
+            throw new Error(`GraphPlugin '${pluginName}' has colliding ${kind} names after prefixing ('${localName}' -> '${resolvedName}')`);
+        }
+        prefixed.add(resolvedName);
+        nameMap.set(localName, resolvedName);
+    }
+    return nameMap;
+};
+const assertNoCollisions = (pluginName, kind, localNames, existingNames) => {
+    const existing = new Set(existingNames);
+    for (const localName of localNames) {
+        if (existing.has(localName)) {
+            throw new Error(`GraphPlugin '${pluginName}' ${kind} '${localName}' collides with an existing ${kind}`);
+        }
+    }
+};
+const prefixDefinitions = (definitions, nameMap) => {
+    return Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [
+        nameMap.get(name) ?? name,
+        definition,
+    ]));
+};
+const rewriteSerializedPhaseRule = (rule, namedRuleMap, namedRuleSetMap) => {
+    if (isNamedRuleRef(rule)) {
+        const mapped = namedRuleMap.get(rule.namedRule);
+        if (mapped) {
+            return { namedRule: mapped };
+        }
+        return rule;
+    }
+    if (isNamedRuleSetRef(rule)) {
+        const mapped = namedRuleSetMap.get(rule.namedRuleSet);
+        if (mapped) {
+            return { namedRuleSet: mapped };
+        }
+        return rule;
+    }
+    return rule;
+};
+const rewriteSerializedRuleSet = (ruleSet, namedRuleMap, namedRuleSetMap) => {
+    return {
+        name: ruleSet.name,
+        rules: (ruleSet.rules ?? []).map((rule) => rewriteSerializedPhaseRule(rule, namedRuleMap, namedRuleSetMap)),
+    };
+};
+const rewriteNamedRuleSetDefinition = (definition, namedRuleMap, namedRuleSetMap) => {
+    if (typeof definition === 'function') {
+        return () => RuleSet.deseriaize(rewriteSerializedRuleSet(definition().serialize(), namedRuleMap, namedRuleSetMap));
+    }
+    const serialized = definition instanceof RuleSet ? definition.serialize() : definition;
+    return RuleSet.deseriaize(rewriteSerializedRuleSet(serialized, namedRuleMap, namedRuleSetMap));
+};
+const prefixNamedRuleSetDefinitions = (definitions, nameMap, namedRuleMap, namedRuleSetMap) => {
+    return Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [
+        nameMap.get(name) ?? name,
+        rewriteNamedRuleSetDefinition(definition, namedRuleMap, namedRuleSetMap),
+    ]));
+};
+const prefixPhasePlan = (phases, namedRuleMap, namedRuleSetMap) => {
+    return phases.map((phase) => {
+        if (!isNamedPhase(phase.phase)) {
+            throw new Error(`GraphPlugin phases contains unsupported phase '${String(phase.phase)}'`);
+        }
+        return {
+            phase: phase.phase,
+            rules: phase.rules.map((rule) => {
+                if (isNamedRuleRef(rule)) {
+                    const mapped = namedRuleMap.get(rule.namedRule);
+                    if (mapped) {
+                        return { namedRule: mapped };
+                    }
+                    return rule;
+                }
+                if (isNamedRuleSetRef(rule)) {
+                    const mapped = namedRuleSetMap.get(rule.namedRuleSet);
+                    if (mapped) {
+                        return { namedRuleSet: mapped };
+                    }
+                    return rule;
+                }
+                return rule;
+            }),
+        };
+    });
+};
+export const resolveGraphPlugins = (input) => {
+    let namedRules = input.namedRules ?? new NamedRuleRegistry();
+    let namedRuleSets = input.namedRuleSets ?? new NamedRuleSetRegistry();
+    const phases = [];
+    for (const pluginRef of input.plugins) {
+        const plugin = input.pluginRegistry.resolve(pluginRef.plugin);
+        const buildResult = plugin.build({
+            options: resolveGraphPluginOptions(plugin, pluginRef.options),
+            namedRules,
+            namedRuleSets,
+        });
+        const localNamedRules = buildResult.namedRules ?? {};
+        const localNamedRuleSets = buildResult.namedRuleSets ?? {};
+        const namedRuleMap = createPrefixedNameMap(plugin.name, Object.keys(localNamedRules), 'named rule');
+        const namedRuleSetMap = createPrefixedNameMap(plugin.name, Object.keys(localNamedRuleSets), 'named rule set');
+        const prefixedNamedRules = prefixDefinitions(localNamedRules, namedRuleMap);
+        const prefixedNamedRuleSets = prefixNamedRuleSetDefinitions(localNamedRuleSets, namedRuleSetMap, namedRuleMap, namedRuleSetMap);
+        assertNoCollisions(plugin.name, 'named rule', Object.keys(prefixedNamedRules), namedRules.names());
+        assertNoCollisions(plugin.name, 'named rule set', Object.keys(prefixedNamedRuleSets), namedRuleSets.names());
+        namedRules = namedRules.registerMany(prefixedNamedRules);
+        namedRuleSets = namedRuleSets.registerMany(prefixedNamedRuleSets);
+        const pluginPhases = prefixPhasePlan(buildResult.phases ?? [], namedRuleMap, namedRuleSetMap);
+        phases.push(...pluginPhases);
+    }
+    return {
+        phases,
+        namedRules,
+        namedRuleSets,
+    };
+};

package/dist/esm/Graph/GraphPlugin.test.d.ts

@@ -0,0 +1 @@
+export {};