@astrale-os/kernel-dsl 0.2.0-beta.42 → 0.2.0-beta.44

package/dist/v1/schema/compatibility/legacy/index.js

@@ -1,145 +0,0 @@
-import { Key } from '../../../addressing/index.js';
-import { compareUnicode } from '../../../addressing/ordering.js';
-import { compareFacet } from '../comparators/index.js';
-import { fingerprintMeaning } from '../comparators/values.js';
-import { compareMeaning, compareStructure } from '../compare.js';
-import { prepare, retainedContext } from '../scope.js';
-export function compareDependencyMeaning(dependent, target) {
-    return legacyMeaning(compareMeaning({ scope: { kind: 'dependency', dependent }, target }));
-}
-export function compareMemberMeaning(source, target, roots) {
-    return legacyMeaning(compareMeaning({ scope: { kind: 'members', source, roots }, target }));
-}
-export function compareDependencyStructure(dependent, target) {
-    const report = compareStructure({ scope: { kind: 'dependency', dependent }, target });
-    const failed = new Set(report.assessments.filter((item) => !item.satisfied).map((item) => item.observation.id));
-    const changes = report.entries.flatMap((entry) => entry.observations.filter((item) => failed.has(item.id)).map((item) => changeOf(entry, item)));
-    return Object.freeze({
-        kind: 'structure',
-        version: 1,
-        dependency: report.scope.source.origin,
-        source: report.scope.source.revision,
-        target: report.scope.target.revision,
-        footprint: Object.freeze(report.entries
-            .filter((entry) => Key.origin(entry.subject.key) === report.scope.source.origin &&
-            entry.observations.some((item) => item.before !== undefined))
-            .map((entry) => entry.subject.key)),
-        changes: Object.freeze(changes),
-        fingerprint: report.evidence.fingerprint,
-    });
-}
-export function footprintOf(dependent, origin) {
-    const { source } = retainedContext(dependent, origin, '/origin');
-    const report = compareMeaning({ scope: { kind: 'dependency', dependent }, target: source });
-    return Object.freeze(report.entries.map((entry) => Object.freeze({
-        ...entry.subject,
-        ...(entry.subject.kind === 'class'
-            ? {
-                level: strongest(entry).facet === 'class.inherit'
-                    ? 'inherit'
-                    : 'reference',
-            }
-            : {}),
-    })));
-}
-export function meaningOf(schema, key, level = 'reference') {
-    const context = prepare({
-        scope: { kind: 'members', source: schema, roots: [key] },
-        target: schema,
-    });
-    const coordinate = context.roots[0].coordinate;
-    const facet = coordinate.kind === 'class'
-        ? level === 'inherit'
-            ? 'class.inherit'
-            : 'class.reference'
-        : coordinate.kind === 'method'
-            ? 'method.signature'
-            : coordinate.kind === 'property'
-                ? 'property'
-                : coordinate.ref.kind === 'function'
-                    ? 'function.signature'
-                    : coordinate.ref.kind;
-    return compareFacet({ context, pair: context.pair(coordinate), facet }).before;
-}
-function strongest(entry) {
-    return (entry.observations.find((item) => item.facet === 'class.inherit') ??
-        entry.observations.find((item) => item.facet !== 'property.required') ??
-        entry.observations[0]);
-}
-function legacyMeaning(report) {
-    const coordinates = [];
-    const footprint = [];
-    const changes = [];
-    const additions = [];
-    for (const entry of report.entries) {
-        const added = entry.observations.find((item) => item.facet === 'property.required');
-        if (added !== undefined)
-            additions.push(changeOf(entry, added));
-        const observation = strongest(entry);
-        const change = changeOf(entry, observation);
-        if (observation.before === undefined) {
-            continue;
-        }
-        footprint.push(entry.subject.key);
-        coordinates.push([
-            entry.subject.key,
-            fingerprintMeaning(observation.before),
-            observation.after === undefined ? null : fingerprintMeaning(observation.after),
-        ]);
-        if (change !== undefined)
-            changes.push(change);
-    }
-    additions.sort((a, b) => compareUnicode(a.key, b.key));
-    const identity = {
-        version: 3,
-        dependency: report.scope.source.origin,
-        source: report.scope.source.revision,
-        target: report.scope.target.revision,
-    };
-    return Object.freeze({
-        ...identity,
-        footprint: Object.freeze(footprint),
-        changes: Object.freeze([...changes, ...additions]),
-        fingerprint: fingerprintMeaning({
-            ...identity,
-            coordinates,
-            additions: additions.map(({ key, targetFingerprint }) => [key, targetFingerprint]),
-        }),
-    });
-}
-function changeOf(entry, observation) {
-    const key = entry.subject.key;
-    if (observation.state === 'equal')
-        return undefined;
-    if (observation.before === undefined)
-        return Object.freeze({
-            key,
-            kind: 'added',
-            targetFingerprint: fingerprintMeaning(observation.after),
-            meaning: observation.after,
-        });
-    const sourceFingerprint = fingerprintMeaning(observation.before);
-    if (observation.after === undefined)
-        return Object.freeze({ key, kind: 'missing', sourceFingerprint });
-    return Object.freeze({
-        key,
-        kind: 'changed',
-        sourceFingerprint,
-        targetFingerprint: fingerprintMeaning(observation.after),
-        differences: observation.differences,
-    });
-}
-/** One line an operator can act on, naming the exact paths of a changed meaning. */
-export function describeMeaningChange(change) {
-    switch (change.kind) {
-        case 'missing':
-            return `${change.key} missing`;
-        case 'added':
-            return `${change.key} added as an obligation`;
-        case 'changed': {
-            const paths = change.differences.map(({ path }) => path);
-            const shown = paths.slice(0, 3).join(', ');
-            return `${change.key} changed at ${paths.length > 3 ? `${shown} and ${paths.length - 3} more` : shown}`;
-        }
-    }
-}