@agentshouse/mdmodel 0.1.0-alpha.9 → 0.1.0-c68e2039f1ca8

package/dist/definition.js

@@ -1,171 +1,492 @@
-import { typeNameFromPath } from './paths.js';
-import { refusal } from './refuse.js';
-function refuse(file, rule, location) {
-    return location === undefined ? refusal(file, rule) : refusal(file, rule, {
-        location
-    });
-}
-function isRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-function requiredFlag(value) {
-    if (value === undefined) return false;
-    if (typeof value === 'boolean') return value;
+import { MEMBER_FIELD, RECEIVED_FIELD, SITE_FIELD } from './fields.js';
+import { equalValue, isRecord, jsValue, parseYamlMapping, YamlError } from './yaml.js';
+export const JSON_TYPES = [
+    'string',
+    'number',
+    'integer',
+    'boolean',
+    'object',
+    'array',
+    'null',
+];
+export const BUILT_IN_TYPE = 'any';
+export const ATTACHMENT = 'attachment';
+const SCALAR_TYPES = new Set(['string', 'number', 'integer', 'boolean']);
+const DEFS_REFERENCE = '#/$defs/';
+const UNRESOLVED = /[\u0000-\u001f\u007f%[\]\\^{|}]|\s$/u;
+const ARRAY_INDEX = /^(?:0|[1-9][0-9]*)$/u;
+const HOUSE_KEYS = {
+    type: { prose: false },
+    [SITE_FIELD]: { prose: false },
+    [RECEIVED_FIELD]: { prose: false },
+};
+function refuse(rule, location) {
+    return location === undefined ? { rule } : { rule, location };
+}
+export function escapePointer(key) {
+    return key.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+function unescapePointer(segment) {
+    return segment.replaceAll('~1', '/').replaceAll('~0', '~');
+}
+export function refTarget(reference, defs) {
+    if (!reference.startsWith(DEFS_REFERENCE) || UNRESOLVED.test(reference))
+        return undefined;
+    const segments = reference.slice(DEFS_REFERENCE.length).split('/');
+    const [name = '', ...rest] = segments.map(unescapePointer);
+    if (segments.some((segment) => escapePointer(unescapePointer(segment)) !== segment))
+        return undefined;
+    if (!Object.hasOwn(defs, name))
+        return undefined;
+    let node = defs[name];
+    for (let index = 0; index < rest.length; index += 1) {
+        const keyword = rest[index];
+        if (!isRecord(node) || !Object.hasOwn(node, keyword) || !Object.hasOwn(KEYWORDS, keyword))
+            return undefined;
+        const check = KEYWORDS[keyword];
+        const held = node[keyword];
+        if (check === SCHEMA) {
+            node = held;
+            continue;
+        }
+        const key = rest[index + 1];
+        index += 1;
+        if (check === SCHEMA_LIST && Array.isArray(held) && key !== undefined && ARRAY_INDEX.test(key))
+            node = held[Number(key)];
+        else if (check === SCHEMA_MAP &&
+            isRecord(held) &&
+            key !== undefined &&
+            Object.hasOwn(held, key))
+            node = held[key];
+        else
+            return undefined;
+        if (node === undefined)
+            return undefined;
+    }
+    return { name, node };
+}
+function compiles(pattern) {
+    if (typeof pattern !== 'string')
+        return false;
+    try {
+        new RegExp(pattern, 'u');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function finite(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function count(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+function strings(value) {
+    return (Array.isArray(value) &&
+        value.every((item) => typeof item === 'string') &&
+        new Set(value).size === value.length);
+}
+function schemaFailure(value, at, context) {
+    if (typeof value === 'boolean')
+        return undefined;
+    if (!isRecord(value))
+        return refuse('schema', at);
+    for (const [key, held] of Object.entries(value)) {
+        const where = `${at}/${escapePointer(key)}`;
+        if (!Object.hasOwn(KEYWORDS, key))
+            return refuse('schema-keyword', where);
+        const check = KEYWORDS[key];
+        if (check === SCHEMA) {
+            const failure = schemaFailure(held, where, context);
+            if (failure !== undefined)
+                return failure;
+            continue;
+        }
+        if (check === SCHEMA_LIST) {
+            if (!Array.isArray(held) || held.length === 0)
+                return refuse(key, where);
+            for (const [index, item] of held.entries()) {
+                const failure = schemaFailure(item, `${where}/${index}`, context);
+                if (failure !== undefined)
+                    return failure;
+            }
+            continue;
+        }
+        if (check === SCHEMA_MAP) {
+            if (!isRecord(held))
+                return refuse(key, where);
+            for (const [name, item] of Object.entries(held)) {
+                if (key === 'patternProperties' && !compiles(name))
+                    return refuse(key, `${where}/${escapePointer(name)}`);
+                const failure = schemaFailure(item, `${where}/${escapePointer(name)}`, context);
+                if (failure !== undefined)
+                    return failure;
+            }
+            continue;
+        }
+        if (!check(held, where, value, context))
+            return refuse(key, where);
+    }
     return undefined;
 }
-function stringList(value) {
-    if (!Array.isArray(value) || value.length === 0) return undefined;
-    if (!value.every((item)=>typeof item === 'string' && item !== '')) return undefined;
-    return value;
+const SCHEMA = () => true;
+const SCHEMA_LIST = () => true;
+const SCHEMA_MAP = () => true;
+const ANY = () => true;
+const TEXT = (value) => typeof value === 'string';
+const FLAG = (value) => typeof value === 'boolean';
+const NUMBER = finite;
+const COUNT = count;
+const KEYWORDS = {
+    $comment: TEXT,
+    $ref: (value, _at, _node, context) => typeof value === 'string' && refTarget(value, context.defs) !== undefined,
+    $defs: SCHEMA_MAP,
+    allOf: SCHEMA_LIST,
+    anyOf: SCHEMA_LIST,
+    oneOf: SCHEMA_LIST,
+    prefixItems: SCHEMA_LIST,
+    not: SCHEMA,
+    if: SCHEMA,
+    then: SCHEMA,
+    else: SCHEMA,
+    items: SCHEMA,
+    contains: SCHEMA,
+    additionalProperties: SCHEMA,
+    unevaluatedProperties: SCHEMA,
+    unevaluatedItems: SCHEMA,
+    propertyNames: SCHEMA,
+    contentSchema: SCHEMA,
+    properties: SCHEMA_MAP,
+    patternProperties: SCHEMA_MAP,
+    dependentSchemas: SCHEMA_MAP,
+    type: (value) => (typeof value === 'string' && JSON_TYPES.includes(value)) ||
+        (Array.isArray(value) &&
+            value.length > 0 &&
+            strings(value) &&
+            value.every((item) => JSON_TYPES.includes(item))),
+    enum: (value) => Array.isArray(value) && value.length > 0,
+    const: ANY,
+    multipleOf: (value) => finite(value) && value > 0,
+    maximum: NUMBER,
+    exclusiveMaximum: NUMBER,
+    minimum: NUMBER,
+    exclusiveMinimum: NUMBER,
+    maxLength: COUNT,
+    minLength: COUNT,
+    maxItems: COUNT,
+    minItems: COUNT,
+    maxContains: COUNT,
+    minContains: COUNT,
+    maxProperties: COUNT,
+    minProperties: COUNT,
+    pattern: compiles,
+    uniqueItems: FLAG,
+    required: strings,
+    dependentRequired: (value) => isRecord(value) && Object.values(value).every(strings),
+    format: TEXT,
+    contentEncoding: TEXT,
+    contentMediaType: TEXT,
+    title: TEXT,
+    description: TEXT,
+    default: ANY,
+    examples: (value) => Array.isArray(value),
+    deprecated: FLAG,
+    readOnly: FLAG,
+    writeOnly: FLAG,
+    reference: (value, _at, node, context) => {
+        if (node.type !== 'string')
+            return false;
+        const named = typeof value === 'string' ? [value] : value;
+        return (Array.isArray(named) &&
+            named.length > 0 &&
+            strings(named) &&
+            named.every((name) => name === BUILT_IN_TYPE || name === ATTACHMENT || context.types.has(name)));
+    },
+};
+function sharedType(values) {
+    if (values.length === 0)
+        return undefined;
+    if (values.every((value) => typeof value === 'string'))
+        return 'string';
+    if (values.every((value) => typeof value === 'number'))
+        return 'number';
+    if (values.every((value) => typeof value === 'boolean'))
+        return 'boolean';
+    return undefined;
 }
-const SCALAR_KINDS = new Set([
-    'text',
-    'string',
-    'number',
-    'date',
-    'enum',
-    'reference'
-]);
-function parseScalar(file, location, spec, required) {
-    const kind = spec.kind;
-    if (kind === 'text') return {
-        kind: 'text',
-        required
-    };
-    if (kind === 'string') return {
-        kind: 'string',
-        required
-    };
-    if (kind === 'number') return {
-        kind: 'number',
-        required
-    };
-    if (kind === 'date') return {
-        kind: 'date',
-        required
-    };
-    if (kind === 'enum') {
-        const values = stringList(spec.values);
-        if (values === undefined) return refuse(file, 'definition-enum-values', location);
-        return {
-            kind: 'enum',
-            required,
-            values
-        };
-    }
-    if (kind === 'reference') {
-        if (typeof spec.to !== 'string' || spec.to === '') return refuse(file, 'definition-reference-to', location);
-        return {
-            kind: 'reference',
-            required,
-            to: spec.to
-        };
-    }
-    return refuse(file, 'definition-field-kind', location);
-}
-function extraKeys(spec, allowed) {
-    return Object.keys(spec).some((key)=>!allowed.includes(key));
-}
-function parseList(file, location, spec, required, malformed) {
-    if (typeof spec.of !== 'string' || !SCALAR_KINDS.has(spec.of)) {
-        return refuse(file, 'definition-list-of', location);
-    }
-    const allowed = spec.of === 'enum' ? [
-        'kind',
-        'required',
-        'of',
-        'values'
-    ] : spec.of === 'reference' ? [
-        'kind',
-        'required',
-        'of',
-        'to'
-    ] : [
-        'kind',
-        'required',
-        'of'
-    ];
-    if (extraKeys(spec, allowed)) return refuse(file, malformed, location);
-    const inner = parseScalar(file, location, {
-        ...spec,
-        kind: spec.of
-    }, false);
-    if ('rule' in inner) return inner;
-    return {
-        kind: 'list',
-        required,
-        of: inner
+function singleType(type) {
+    if (typeof type === 'string')
+        return type;
+    if (!Array.isArray(type))
+        return undefined;
+    const kept = type.filter((one) => one !== 'null');
+    return kept.length === 1 ? kept[0] : undefined;
+}
+function firstOf(held, read) {
+    for (const node of held) {
+        const value = read(node);
+        if (value !== undefined)
+            return value;
+    }
+    return undefined;
+}
+function conjoined(nodes, defs, ancestry) {
+    const held = [];
+    const reached = new Set(ancestry);
+    const visit = (node) => {
+        if (!isRecord(node) || held.includes(node))
+            return;
+        held.push(node);
+        if (typeof node.$ref === 'string') {
+            const target = refTarget(node.$ref, defs)?.node;
+            if (target !== undefined && !reached.has(target)) {
+                reached.add(target);
+                visit(target);
+            }
+        }
+        if (Array.isArray(node.allOf))
+            for (const one of node.allOf)
+                visit(one);
     };
+    for (const node of nodes)
+        visit(node);
+    return { held, ancestry: reached };
 }
-function parseField(file, location, value) {
-    if (!isRecord(value) || typeof value.kind !== 'string') return refuse(file, 'definition-field', location);
-    const required = requiredFlag(value.required);
-    if (required === undefined) return refuse(file, 'definition-field', location);
-    if (value.kind === 'list') return parseList(file, location, value, required, 'definition-field');
-    const allowed = value.kind === 'enum' ? [
-        'kind',
-        'required',
-        'values'
-    ] : value.kind === 'reference' ? [
-        'kind',
-        'required',
-        'to'
-    ] : [
-        'kind',
-        'required'
-    ];
-    if (extraKeys(value, allowed)) return refuse(file, 'definition-field', location);
-    return parseScalar(file, location, value, required);
-}
-function parseSection(file, location, value) {
-    if (!isRecord(value) || value.kind !== 'text' && value.kind !== 'list') {
-        return refuse(file, 'definition-section-kind', location);
-    }
-    const required = requiredFlag(value.required);
-    if (required === undefined) return refuse(file, 'definition-section', location);
-    if (value.kind === 'list') return parseList(file, location, value, required, 'definition-section');
-    if (extraKeys(value, [
-        'kind',
-        'required'
-    ])) return refuse(file, 'definition-section', location);
+function variantsOf(node) {
+    return [
+        ...(Array.isArray(node.anyOf) ? node.anyOf : []),
+        ...(Array.isArray(node.oneOf) ? node.oneOf : []),
+        node.then,
+        node.else,
+        ...(isRecord(node.dependentSchemas) ? Object.values(node.dependentSchemas) : []),
+    ].filter(isRecord);
+}
+function united(left, right) {
+    if (left === undefined || right === undefined)
+        return undefined;
+    return [...left, ...right.filter((value) => !left.some((held) => equalValue(held, value)))];
+}
+function joined(left, right) {
+    const type = left.type === right.type ? left.type : undefined;
+    const format = left.format === right.format ? left.format : undefined;
+    const values = united(left.values, right.values);
+    const reference = united(left.reference, right.reference);
+    const items = left.items !== undefined && right.items !== undefined
+        ? joined(left.items, right.items)
+        : undefined;
     return {
-        kind: 'text',
-        required
+        ...(type === undefined ? {} : { type }),
+        ...(format === undefined ? {} : { format }),
+        ...(values === undefined ? {} : { values }),
+        ...(reference === undefined ? {} : { reference }),
+        prose: left.prose && right.prose,
+        ...(items === undefined ? {} : { items }),
     };
 }
-export function readDefinition(file, document) {
-    if (document.type !== 'definition') return refuse(file, 'definition-type');
-    const name = typeNameFromPath(file);
-    if (name === '') return refuse(file, 'definition-type');
-    for (const key of Object.keys(document.fields)){
-        if (key !== 'type' && key !== 'fields' && key !== 'sections') {
-            return refuse(file, 'definition-shape', key);
+function propertiesOf(held, defs, ancestry) {
+    const declared = new Map();
+    for (const node of held) {
+        if (!isRecord(node.properties))
+            continue;
+        for (const [name, schema] of Object.entries(node.properties))
+            declared.set(name, [...(declared.get(name) ?? []), schema]);
+    }
+    const properties = Object.create(null);
+    for (const [name, schemas] of declared)
+        properties[name] = factsOf(schemas, defs, ancestry);
+    const variants = Object.create(null);
+    for (const branch of held.flatMap(variantsOf)) {
+        for (const [name, facts] of Object.entries(factsOf([branch], defs, ancestry).properties ?? {})) {
+            if (Object.hasOwn(properties, name))
+                continue;
+            variants[name] = Object.hasOwn(variants, name) ? joined(variants[name], facts) : facts;
         }
     }
-    const fieldsValue = document.fields.fields;
-    const sectionsValue = document.fields.sections;
-    if (fieldsValue !== undefined && !isRecord(fieldsValue)) return refuse(file, 'definition-fields', 'fields');
-    if (sectionsValue !== undefined && !isRecord(sectionsValue)) {
-        return refuse(file, 'definition-sections', 'sections');
+    Object.assign(properties, variants);
+    return Object.keys(properties).length === 0 ? undefined : properties;
+}
+function factsOf(nodes, defs, ancestry) {
+    const { held, ancestry: reached } = conjoined(nodes, defs, ancestry);
+    const listed = held.flatMap((node) => Array.isArray(node.enum) ? [node.enum] : node.const !== undefined ? [[node.const]] : []);
+    const values = listed.length === 0
+        ? undefined
+        : listed.reduce((kept, list) => kept.filter((value) => list.some((other) => equalValue(other, value))));
+    const type = firstOf(held, (node) => singleType(node.type)) ??
+        (values === undefined ? undefined : sharedType(values));
+    const reference = firstOf(held, (node) => typeof node.reference === 'string'
+        ? [node.reference]
+        : Array.isArray(node.reference)
+            ? node.reference
+            : undefined);
+    const format = firstOf(held, (node) => typeof node.format === 'string' ? node.format : undefined);
+    const prose = type === 'string' &&
+        values === undefined &&
+        format === undefined &&
+        reference === undefined &&
+        held.every((node) => node.pattern === undefined);
+    const listedItems = held.flatMap((node) => (node.items === undefined ? [] : [node.items]));
+    const items = type === 'array' && listedItems.length > 0 ? factsOf(listedItems, defs, reached) : undefined;
+    const mapped = type === 'object' || type === undefined;
+    const properties = mapped ? propertiesOf(held, defs, reached) : undefined;
+    const patterns = mapped
+        ? held.flatMap((node) => Object.entries(isRecord(node.patternProperties) ? node.patternProperties : {}).map(([pattern, schema]) => ({ pattern, facts: factsOf([schema], defs, reached) })))
+        : [];
+    const opened = mapped
+        ? held.flatMap((node) => [node.additionalProperties, node.unevaluatedProperties].filter(isRecord))
+        : [];
+    const additional = opened.length === 0 ? undefined : factsOf(opened, defs, reached);
+    return {
+        ...(type === undefined ? {} : { type }),
+        ...(format === undefined ? {} : { format }),
+        ...(values === undefined ? {} : { values }),
+        ...(reference === undefined ? {} : { reference }),
+        prose,
+        ...(items === undefined ? {} : { items }),
+        ...(properties === undefined ? {} : { properties }),
+        ...(patterns.length === 0 ? {} : { patterns }),
+        ...(additional === undefined ? {} : { additional }),
+    };
+}
+export function valueFacts(node, defs) {
+    return factsOf([node], defs, new Set());
+}
+export function memberFacts(facts, key) {
+    if (facts.properties !== undefined && Object.hasOwn(facts.properties, key))
+        return facts.properties[key];
+    const pattern = facts.patterns?.find((one) => new RegExp(one.pattern, 'u').test(key));
+    return pattern === undefined ? facts.additional : pattern.facts;
+}
+function reachedDefs(value, defs, reached) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            reachedDefs(item, defs, reached);
+        return;
     }
-    const fields = Object.create(null);
-    for (const [fieldName, spec] of Object.entries(fieldsValue ?? {})){
-        const parsed = parseField(file, fieldName, spec);
-        if ('rule' in parsed) return parsed;
-        fields[fieldName] = parsed;
+    if (!isRecord(value))
+        return;
+    for (const [key, held] of Object.entries(value)) {
+        if (key === '$ref' && typeof held === 'string') {
+            const name = refTarget(held, defs)?.name;
+            if (name === undefined || Object.hasOwn(reached, name))
+                continue;
+            reached[name] = defs[name];
+            reachedDefs(defs[name], defs, reached);
+            continue;
+        }
+        reachedDefs(held, defs, reached);
     }
+}
+function readSections(value, at, context) {
+    const failed = (rule, location) => ({ failure: refuse(rule, location) });
+    if (!isRecord(value))
+        return failed('sections', at);
     const sections = Object.create(null);
-    for (const [sectionName, spec] of Object.entries(sectionsValue ?? {})){
-        const parsed = parseSection(file, sectionName, spec);
-        if ('rule' in parsed) return parsed;
-        sections[sectionName] = parsed;
+    for (const [name, spec] of Object.entries(value)) {
+        const where = `${at}/${escapePointer(name)}`;
+        if (!isRecord(spec) || (spec.kind !== 'text' && spec.kind !== 'list'))
+            return failed('sections', where);
+        const allowed = spec.kind === 'list' ? ['kind', 'required', 'items'] : ['kind', 'required'];
+        const extra = Object.keys(spec).find((key) => !allowed.includes(key));
+        if (extra !== undefined)
+            return failed('sections', `${where}/${escapePointer(extra)}`);
+        if (spec.required !== undefined && typeof spec.required !== 'boolean')
+            return failed('sections', `${where}/required`);
+        const required = spec.required === true;
+        if (spec.kind === 'text') {
+            sections[name] = { kind: 'text', required };
+            continue;
+        }
+        if (spec.items === undefined)
+            return failed('sections', `${where}/items`);
+        const failure = schemaFailure(spec.items, `${where}/items`, context);
+        if (failure !== undefined)
+            return { failure };
+        const items = valueFacts(spec.items, context.defs);
+        if (items.type === undefined || !SCALAR_TYPES.has(items.type))
+            return failed('sections', `${where}/items`);
+        sections[name] = { kind: 'list', required, items };
+    }
+    return { sections };
+}
+function deepFreeze(value) {
+    if (value !== null && typeof value === 'object' && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const held of Object.values(value))
+            deepFreeze(held);
     }
+    return value;
+}
+function readType(name, value, context) {
+    const at = `/${escapePointer(name)}`;
+    if (!isRecord(value))
+        return refuse('schema', at);
+    const { sections: declared, member_document: mark, ...schema } = value;
+    if (mark !== undefined && typeof mark !== 'boolean')
+        return refuse('member_document', `${at}/member_document`);
+    const read = declared === undefined
+        ? { sections: Object.create(null) }
+        : readSections(declared, `${at}/sections`, context);
+    if ('failure' in read)
+        return read.failure;
+    const failure = schemaFailure(schema, at, context);
+    if (failure !== undefined)
+        return failure;
+    const memberDocument = mark === true;
+    const root = valueFacts(schema, context.defs);
+    const fields = Object.assign(Object.create(null), root.properties);
+    if (memberDocument && !Object.hasOwn(fields, MEMBER_FIELD))
+        fields[MEMBER_FIELD] = { type: 'string', prose: false };
+    const defs = Object.create(null);
+    reachedDefs(value, context.defs, defs);
     return {
         name,
-        file,
+        memberDocument,
+        frontmatter: { ...root, properties: { ...HOUSE_KEYS, ...fields } },
         fields,
-        sections
+        sections: read.sections,
+        shape: { schema: value, defs },
     };
 }
-
-//# sourceMappingURL=definition.js.map
+function lineAt(text, offset) {
+    return text.slice(0, offset).split(/\r\n|\r|\n/).length;
+}
+export function readSchema(text) {
+    let root;
+    try {
+        root = jsValue(parseYamlMapping(text, 0, text.length));
+    }
+    catch (error) {
+        if (error instanceof YamlError)
+            return refuse('schema-yaml', `line ${lineAt(text, error.offset)}`);
+        throw error;
+    }
+    const defs = root.$defs ?? Object.create(null);
+    if (!isRecord(defs))
+        return refuse('$defs', '/$defs');
+    const names = Object.keys(root).filter((key) => key !== '$defs');
+    for (const name of names) {
+        if (name === '' || name.startsWith('$') || name === BUILT_IN_TYPE || name === ATTACHMENT)
+            return refuse('schema-type-name', `/${escapePointer(name)}`);
+    }
+    const context = { defs, types: new Set(names) };
+    for (const [name, def] of Object.entries(defs)) {
+        const failure = schemaFailure(def, `/$defs/${escapePointer(name)}`, context);
+        if (failure !== undefined)
+            return failure;
+    }
+    const types = Object.create(null);
+    let marked = false;
+    for (const name of names) {
+        const definition = readType(name, root[name], context);
+        if ('rule' in definition)
+            return definition;
+        if (definition.memberDocument) {
+            if (marked)
+                return refuse('member_document', `/${escapePointer(name)}/member_document`);
+            marked = true;
+        }
+        types[name] = deepFreeze(definition);
+    }
+    return Object.freeze({ types: Object.freeze(types) });
+}

package/dist/divide.d.ts

@@ -0,0 +1,3 @@
+import type { Division, DivisionContext, Document } from './types.js';
+export declare function divide(document: Document, file: string, context: DivisionContext): Division;
+//# sourceMappingURL=divide.d.ts.map

package/dist/divide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"divide.d.ts","sourceRoot":"","sources":["../src/divide.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,QAAQ,EAAgB,MAAM,YAAY,CAAC;AA4WpF,wBAAgB,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,QAAQ,CAc3F"}