@prestack/thread 0.0.1

package/dist/core/condition.d.ts

@@ -0,0 +1,52 @@
+import { type Actor } from './actor.ts';
+export declare const COMPARE_OPS: readonly ["eq", "neq", "lt", "lte", "gt", "gte", "in", "has"];
+export type CompareOp = (typeof COMPARE_OPS)[number];
+export declare const AGGREGATIONS: readonly ["count", "sum", "min", "max", "avg"];
+export declare const ACTOR_FACTS: readonly ["id", "roles", "entitlements", ...("run" | "address" | "device" | "replay")[]];
+export declare const AGO: RegExp;
+export type Operand = {
+    readonly value: string | number | boolean | null;
+} | {
+    readonly field: string;
+} | {
+    readonly was: string;
+} | {
+    readonly outer: string;
+} | {
+    readonly actor: (typeof ACTOR_FACTS)[number];
+} | {
+    readonly now: true;
+} | {
+    readonly ago: string;
+} | {
+    readonly agg: {
+        readonly of: string;
+        readonly how: (typeof AGGREGATIONS)[number];
+        readonly field?: string;
+        readonly where?: Condition;
+    };
+};
+export type Condition = {
+    readonly all: readonly Condition[];
+} | {
+    readonly any: readonly Condition[];
+} | {
+    readonly not: Condition;
+} | {
+    readonly is: Operand;
+    readonly op: CompareOp;
+    readonly than: Operand;
+};
+export declare function walkOperands(condition: Condition, take: (one: Operand) => void): void;
+export declare function mentionsActor(condition: Condition): boolean;
+export declare function agoSeconds(ago: string): number | undefined;
+export declare function satisfies(condition: Condition, actor: Actor): boolean;
+export declare const CONDITION_ANSWERS: readonly ["is", "than", "field", "value", "actor", "ago", "of", "how", "over", "op", "when", "joins"];
+export declare function conditioned(ask: (key: string, question: string) => Promise<string>, say: (line: string) => void, subject: {
+    readonly id: string;
+    readonly fields: readonly string[];
+}, all: readonly {
+    readonly id: string;
+    readonly fields: readonly string[];
+}[]): Promise<Condition | undefined>;
+export declare function said(one: unknown): string;

package/dist/core/condition.js

@@ -0,0 +1,198 @@
+import { ENVIRONMENT } from "./actor.js";
+export const COMPARE_OPS = ['eq', 'neq', 'lt', 'lte', 'gt', 'gte', 'in', 'has'];
+export const AGGREGATIONS = ['count', 'sum', 'min', 'max', 'avg'];
+export const ACTOR_FACTS = ['id', 'roles', 'entitlements', ...ENVIRONMENT.map(([fact]) => fact)];
+export const AGO = /^[1-9][0-9]*[smhd]$/;
+export function walkOperands(condition, take) {
+    if ('all' in condition) {
+        for (const one of condition.all)
+            walkOperands(one, take);
+        return;
+    }
+    if ('any' in condition) {
+        for (const one of condition.any)
+            walkOperands(one, take);
+        return;
+    }
+    if ('not' in condition) {
+        walkOperands(condition.not, take);
+        return;
+    }
+    for (const side of [condition.is, condition.than]) {
+        take(side);
+        if ('agg' in side && side.agg.where !== undefined)
+            walkOperands(side.agg.where, take);
+    }
+}
+export function mentionsActor(condition) {
+    let found = false;
+    walkOperands(condition, (one) => {
+        if ('actor' in one)
+            found = true;
+    });
+    return found;
+}
+export function agoSeconds(ago) {
+    if (!AGO.test(ago))
+        return undefined;
+    const size = Number(ago.slice(0, -1));
+    const unit = ago.slice(-1);
+    return size * (unit === 's' ? 1 : unit === 'm' ? 60 : unit === 'h' ? 3_600 : 86_400);
+}
+export function satisfies(condition, actor) {
+    if ('all' in condition)
+        return condition.all.every((one) => satisfies(one, actor));
+    if ('any' in condition)
+        return condition.any.some((one) => satisfies(one, actor));
+    if ('not' in condition)
+        return !satisfies(condition.not, actor);
+    const reads = (one) => {
+        if ('value' in one)
+            return one.value;
+        if ('actor' in one)
+            return actor[one.actor];
+        return undefined;
+    };
+    const left = reads(condition.is);
+    const right = reads(condition.than);
+    if (left === undefined || right === undefined)
+        return false;
+    const op = condition.op;
+    if (op === 'in')
+        return Array.isArray(right) && right.includes(left);
+    if (op === 'has')
+        return Array.isArray(left) && left.includes(right);
+    if (op === 'eq')
+        return left === right;
+    if (op === 'neq')
+        return left !== right;
+    if (typeof left !== typeof right)
+        return false;
+    if (typeof left !== 'number' && typeof left !== 'string')
+        return false;
+    const other = right;
+    if (op === 'lt')
+        return left < other;
+    if (op === 'lte')
+        return left <= other;
+    if (op === 'gt')
+        return left > other;
+    return left >= other;
+}
+export const CONDITION_ANSWERS = ['is', 'than', 'field', 'value', 'actor', 'ago', 'of', 'how', 'over', 'op', 'when', 'joins'];
+const OPERAND_WORDS = ['field', 'value', 'actor', 'now', 'ago', 'agg'];
+async function sided(ask, say, subject, all, which) {
+    for (;;) {
+        const kind = await ask(which, `  ${which} — ${OPERAND_WORDS.join(', ')}: `);
+        if (kind === 'field') {
+            const id = await ask('field', `    which field — ${subject.fields.join(', ')}: `);
+            if (!subject.fields.includes(id)) {
+                say(`    "${subject.id}" declares no \`${id}\`.\n`);
+                continue;
+            }
+            return { field: id };
+        }
+        if (kind === 'value') {
+            const raw = await ask('value', '    the value (text, a number, true, false, null): ');
+            if (raw === 'null')
+                return { value: null };
+            if (raw === 'true' || raw === 'false')
+                return { value: raw === 'true' };
+            const asNumber = Number(raw);
+            return { value: raw !== '' && Number.isFinite(asNumber) ? asNumber : raw };
+        }
+        if (kind === 'actor') {
+            const fact = await ask('actor', `    which — ${ACTOR_FACTS.join(', ')}: `);
+            if (!ACTOR_FACTS.includes(fact)) {
+                say(`    an actor has ${ACTOR_FACTS.join(', ')} and nothing else.\n`);
+                continue;
+            }
+            return { actor: fact };
+        }
+        if (kind === 'now')
+            return { now: true };
+        if (kind === 'ago') {
+            const span = await ask('ago', '    how long — e.g. 30d, 12h, 15m, 45s: ');
+            if (!AGO.test(span)) {
+                say('    a span is a number and one of s, m, h, d.\n');
+                continue;
+            }
+            return { ago: span };
+        }
+        if (kind === 'agg') {
+            const of = await ask('of', `    over which entity — ${all.map((one) => one.id).join(', ')}: `);
+            const target = all.find((one) => one.id === of);
+            if (target === undefined) {
+                say(`    nothing declares \`${of}\`.\n`);
+                continue;
+            }
+            const how = await ask('how', `    how — ${AGGREGATIONS.join(', ')}: `);
+            if (!AGGREGATIONS.includes(how)) {
+                say(`    an aggregation is ${AGGREGATIONS.join(', ')}.\n`);
+                continue;
+            }
+            if (how === 'count')
+                return { agg: { of, how: 'count' } };
+            const over = await ask('over', `    over which field of ${of} — ${target.fields.join(', ')}: `);
+            if (!target.fields.includes(over)) {
+                say(`    "${of}" declares no \`${over}\`.\n`);
+                continue;
+            }
+            return { agg: { of, how: how, field: over } };
+        }
+        say(`  there is no side called "${kind}".\n`);
+    }
+}
+async function compared(ask, say, subject, all) {
+    for (;;) {
+        const is = await sided(ask, say, subject, all, 'is');
+        const op = await ask('op', `  op — ${COMPARE_OPS.join(', ')}: `);
+        if (!COMPARE_OPS.includes(op)) {
+            say(`  \`${op}\` is not a comparison this provider carries.\n`);
+            continue;
+        }
+        const than = await sided(ask, say, subject, all, 'than');
+        return { is, op: op, than };
+    }
+}
+export async function conditioned(ask, say, subject, all) {
+    const held = [];
+    let joiner = 'all';
+    for (;;) {
+        if (held.length === 0) {
+            const wanted = await ask('when', '  state a condition — y/n: ');
+            if (!wanted.toLowerCase().startsWith('y'))
+                return undefined;
+        }
+        held.push(await compared(ask, say, subject, all));
+        const next = await ask('joins', '  and, or, done: ');
+        if (next === 'done' || next === '')
+            break;
+        if (next === 'and')
+            joiner = 'all';
+        else if (next === 'or')
+            joiner = 'any';
+        else {
+            say('  say and, or, or done.\n');
+            break;
+        }
+    }
+    if (held.length === 0)
+        return undefined;
+    const first = held[0];
+    return held.length === 1 ? first : joiner === 'all' ? { all: held } : { any: held };
+}
+import { quoted } from "./rows.js";
+export function said(one) {
+    if (typeof one === 'string')
+        return quoted(one);
+    if (one === null)
+        return 'null';
+    if (typeof one === 'boolean' || typeof one === 'number')
+        return String(one);
+    if (Array.isArray(one))
+        return `[${one.map((each) => said(each)).join(', ')}]`;
+    if (typeof one === 'object')
+        return `{ ${Object.entries(one).map(([key, held]) => `${key}: ${said(held)}`).join(', ')} }`;
+    return String(one);
+}

package/dist/core/descend.d.ts

@@ -0,0 +1,81 @@
+import ts from 'typescript';
+import type { Finding } from './finding.ts';
+export declare const ROOT: string;
+export declare const TREE: string;
+export declare const THREAD_AT: string;
+export declare const LISTS: readonly ["declares", "derives", "seeds"];
+export interface Row {
+    readonly at?: string;
+    readonly id?: string;
+    readonly describes?: string;
+    readonly by?: string;
+    readonly runs?: string;
+    readonly requires?: readonly string[];
+    readonly takes?: readonly string[];
+    readonly type: string;
+    readonly shape?: ts.Type;
+    readonly fields: ReadonlyMap<string, ts.Expression>;
+    readonly where: string;
+}
+export interface Pass {
+    readonly threaded: ReadonlyMap<string, readonly {
+        readonly list: 'declares' | 'derives' | 'seeds';
+        readonly by: string;
+        readonly row: Row;
+    }[]>;
+    readonly mentioned: ReadonlyMap<string, readonly string[]>;
+    readonly derived: ReadonlyMap<string, Row>;
+    readonly stated: ReadonlyMap<string, Row>;
+    readonly coined: ReadonlyMap<string, {
+        readonly said: readonly string[];
+        readonly under: string;
+        readonly from: readonly string[];
+    }>;
+    readonly broken: readonly Finding[];
+    readonly findings: readonly Finding[];
+    readonly declarations: number;
+    readonly rows: number;
+    readonly sources: readonly string[];
+}
+export type { Finding };
+export declare function under(pass: Pass, id: string, root: string, seen?: Set<string>): boolean;
+export declare function sources(): readonly string[];
+export declare function configured(): {
+    readonly options: ts.CompilerOptions;
+    readonly from: string;
+    readonly trouble?: string;
+};
+export declare function uncompiled(): readonly Finding[];
+export declare function read(at: string): string | undefined;
+export declare function shapesNamed(): ReadonlyMap<string, readonly string[]>;
+export declare function threading(): ReadonlySet<string>;
+export declare function shapeFields(named: string, inside?: string): readonly {
+    readonly name: string;
+    readonly required: boolean;
+    readonly list: boolean;
+    readonly map: boolean;
+    readonly worded: boolean;
+    readonly guide: string;
+}[];
+export interface Field {
+    readonly name: string;
+    readonly required: boolean;
+    readonly list: boolean;
+    readonly map: boolean;
+    readonly boolean: boolean;
+    readonly worded: boolean;
+    readonly guide: string;
+}
+export declare function listShape(at: string, list: string): string | undefined;
+export declare function listFields(at: string, list: string): readonly Field[];
+export declare function rowShape(at: string, list: string): string | undefined;
+interface Held {
+    readonly name: string;
+    readonly type: string;
+    readonly shape: ts.Type;
+    readonly node: ts.ObjectLiteralExpression;
+}
+export declare function nodesIn(at: string): readonly Held[];
+export declare function reached(): readonly string[];
+export declare function forget(): void;
+export declare function descend(): Pass;