eidosmd 0.1.0 → 0.2.0

package/dist/src/core/blueprint.js

@@ -4,10 +4,13 @@
 import { readdirSync, readFileSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { parseFrontmatter } from './frontmatter.js';
-import { defaultFlavor, findFlavor } from './framework.js';
+import { defaultVariant, findVariant } from './framework.js';
 import { headings, sections } from './markdown.js';
 import { kebab } from './naming.js';
-export function blueprintFiles(dir) {
+// Under a markdown framework each collection's `index.md` is the generated
+// leaf, not a blueprint. Under a YAML one the index lives in the document, so
+// `index.md` is an ordinary filename (a blueprint with the id `index`).
+export function blueprintFiles(dir, leafIsIndexMd) {
     let entries;
     try {
         entries = readdirSync(dir);
@@ -16,7 +19,7 @@ export function blueprintFiles(dir) {
         return [];
     }
     return entries
-        .filter((entry) => /\.md$/i.test(entry) && entry.toLowerCase() !== 'index.md' && !entry.startsWith('.'))
+        .filter((entry) => /\.md$/i.test(entry) && !(leafIsIndexMd && entry.toLowerCase() === 'index.md') && !entry.startsWith('.'))
         .filter((entry) => {
         try {
             return statSync(path.join(dir, entry)).isFile();
@@ -69,11 +72,12 @@ export function listBlueprints(framework, collections = framework.collections) {
     const out = [];
     for (const collection of collections) {
         const dir = path.join(framework.root, collection.name);
-        for (const file of blueprintFiles(dir)) {
+        const leafIsIndexMd = framework.format === 'md';
+        for (const file of blueprintFiles(dir, leafIsIndexMd)) {
             out.push(loadBlueprint(framework.root, collection, null, file));
         }
         for (const group of groupDirs(dir)) {
-            for (const file of blueprintFiles(path.join(dir, group))) {
+            for (const file of blueprintFiles(path.join(dir, group), leafIsIndexMd)) {
                 out.push(loadBlueprint(framework.root, collection, group, file));
             }
         }
@@ -99,14 +103,15 @@ export function blueprintId(blueprint) {
 export function blueprintTitle(blueprint) {
     return propertyString(blueprint, 'title') ?? blueprint.stem;
 }
-// The flavor a blueprint follows: the one it names, else its collection's default.
-export function resolveFlavor(blueprint) {
-    const declared = propertyString(blueprint, 'flavor');
+// The variant a blueprint follows: the one it names, else its collection's default.
+export function resolveVariant(blueprint) {
+    // `flavor` is the name before 5.0.0; a root not yet migrated still resolves
+    const declared = propertyString(blueprint, 'variant') ?? propertyString(blueprint, 'flavor');
     if (declared === null) {
-        return { flavor: defaultFlavor(blueprint.collection), declared: null, known: true };
+        return { variant: defaultVariant(blueprint.collection), declared: null, known: true };
     }
-    const flavor = findFlavor(blueprint.collection, declared);
-    return { flavor, declared, known: flavor !== null };
+    const variant = findVariant(blueprint.collection, declared);
+    return { variant, declared, known: variant !== null };
 }
 // A blueprint by path, by id, or by filename stem, in that order.
 export function resolveBlueprint(ref, blueprints, cwd) {

package/dist/src/core/canvas-schema.js

@@ -0,0 +1,148 @@
+// The canvas file, as a JSON Schema (draft 7): what `.eidos/plugins/eidosmd/maps/<id>.yaml`
+// may hold. The file is the whole truth of a canvas; the browser draws it and writes it
+// back, and anything else (a person, an agent) edits it directly.
+import { ANCHORS, EDGE_CAPS } from './canvas.js';
+const hex = { type: 'string', pattern: '^#[0-9a-fA-F]{6}$', description: 'A color as #rrggbb.' };
+const size = { type: 'string', enum: ['small', 'medium', 'large'] };
+const point = { type: 'object', required: ['x', 'y'], additionalProperties: false, properties: { x: { type: 'number' }, y: { type: 'number' } } };
+export const CANVAS_SCHEMA = {
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    title: 'Eidos canvas map',
+    description: 'One canvas of the eidosmd browser: a title and pages, each with frames, nodes, edges, layout, and comment threads. Kept at .eidos/plugins/eidosmd/maps/<id>.yaml; the id is the file name.',
+    type: 'object',
+    required: ['title', 'pages'],
+    additionalProperties: false,
+    properties: {
+        title: { type: 'string' },
+        pages: { type: 'array', minItems: 1, items: { $ref: '#/definitions/page' } },
+    },
+    definitions: {
+        page: {
+            type: 'object',
+            required: ['id', 'title'],
+            additionalProperties: false,
+            properties: {
+                id: { type: 'string', description: 'Unique within the canvas; the URL names it.' },
+                title: { type: 'string' },
+                frames: { type: 'array', items: { $ref: '#/definitions/frame' } },
+                nodes: { type: 'array', items: { $ref: '#/definitions/node' } },
+                edges: { type: 'array', items: { $ref: '#/definitions/edge' } },
+                layout: { type: 'object', description: 'Where each node sits, by node id. A node without a place is laid out by the browser and given one when it first moves.', additionalProperties: point },
+                comments: { type: 'array', items: { $ref: '#/definitions/comment' } },
+            },
+        },
+        node: {
+            type: 'object',
+            required: ['id'],
+            additionalProperties: false,
+            description: 'Exactly one of blueprint, sketch, sticky, text, or annotation says what the node is.',
+            oneOf: [{ required: ['blueprint'] }, { required: ['sketch'] }, { required: ['sticky'] }, { required: ['text'] }, { required: ['annotation'] }],
+            properties: {
+                id: { type: 'string', description: 'Unique within the page; edges name it.' },
+                blueprint: { type: 'string', description: "A blueprint's id; its title, summary, and styled properties are read from the file when drawn." },
+                sketch: { $ref: '#/definitions/sketch' },
+                sticky: { $ref: '#/definitions/sticky' },
+                text: { $ref: '#/definitions/text' },
+                annotation: { $ref: '#/definitions/annotation' },
+                frame: { type: 'string', description: 'The frame this node is attached to; it moves with the frame.' },
+                link: { type: 'object', additionalProperties: false, properties: { page: { type: 'string' }, canvas: { type: 'string' } }, description: 'What the card opens: another page, or another canvas.' },
+                locked: { type: 'boolean' },
+                style: { $ref: '#/definitions/style' },
+                styled: { type: 'boolean', description: 'Styled by hand: a change to a styling property asks before the default is applied.' },
+                box: { type: 'object', required: ['w', 'h'], additionalProperties: false, properties: { w: { type: 'number', minimum: 40 }, h: { type: 'number', minimum: 24 } }, description: 'An exact size; text wraps and scrolls inside it.' },
+            },
+        },
+        sketch: {
+            type: 'object',
+            required: ['label'],
+            additionalProperties: false,
+            description: 'A node that is not a blueprint yet; eidos new promotes it.',
+            properties: {
+                label: { type: 'string', description: 'The title; may be empty until written.' },
+                kind: { type: 'string' },
+                status: { type: 'string' },
+                note: { type: 'string', description: 'The description.' },
+                properties: { type: 'object', additionalProperties: { type: 'string' }, description: 'Values of schema properties that apply to every collection, held until promotion.' },
+            },
+        },
+        sticky: { type: 'object', required: ['text'], additionalProperties: false, properties: { text: { type: 'string' }, color: { type: 'string', enum: ['yellow', 'pink', 'blue', 'green', 'purple', 'orange'] } } },
+        text: { type: 'object', required: ['text'], additionalProperties: false, properties: { text: { type: 'string' }, size, font: { type: 'integer', minimum: 8, maximum: 64, description: 'An exact size in pixels; wins over size.' } } },
+        annotation: { type: 'object', required: ['text'], additionalProperties: false, description: 'A note that points at a node or a frame through an edge from it; one that points at nothing is removed.', properties: { text: { type: 'string' }, color: hex } },
+        style: {
+            type: 'object',
+            additionalProperties: false,
+            description: "A node's own look over the default its properties give it.",
+            properties: {
+                shape: { type: 'string', enum: ['box', 'pill', 'parallelogram'] },
+                color: { ...hex, description: 'The highlight: the bar and the border.' },
+                fill: { type: 'string', enum: ['solid', 'tint', 'none'] },
+                fill_color: hex,
+                size,
+            },
+        },
+        edge: {
+            type: 'object',
+            required: ['from', 'to'],
+            additionalProperties: false,
+            description: 'A flow between two nodes, or to a frame border as frame:<id>.',
+            properties: {
+                from: { type: 'string' },
+                to: { type: 'string' },
+                label: { type: 'string' },
+                label_at: { type: 'number', minimum: 0, maximum: 1, description: 'Where along the line the label sits.' },
+                bend: { type: 'number', description: 'Where the middle segment turns, along its axis.' },
+                from_anchor: { type: 'string', enum: [...ANCHORS] },
+                to_anchor: { type: 'string', enum: [...ANCHORS] },
+                color: hex,
+                style: { type: 'string', enum: ['solid', 'dashed'] },
+                start: { type: 'string', enum: [...EDGE_CAPS] },
+                end: { type: 'string', enum: [...EDGE_CAPS], description: 'A solid arrowhead (triangle) when absent.' },
+            },
+        },
+        frame: {
+            type: 'object',
+            required: ['id', 'title'],
+            additionalProperties: false,
+            description: 'A region drawn around nodes; what is attached moves with it.',
+            properties: {
+                id: { type: 'string' },
+                title: { type: 'string' },
+                x: { type: 'number' },
+                y: { type: 'number' },
+                w: { type: 'number' },
+                h: { type: 'number' },
+                color: { type: 'string', enum: ['none', 'sand', 'sky', 'mint', 'rose', 'lilac'] },
+                locked: { type: 'boolean' },
+                frame: { type: 'string', description: 'The frame this frame is attached to.' },
+            },
+        },
+        comment: {
+            type: 'object',
+            required: ['id', 'x', 'y', 'messages'],
+            additionalProperties: false,
+            description: 'A thread pinned to a point, or to a node with x and y as the offset from it.',
+            properties: {
+                id: { type: 'string' },
+                x: { type: 'number' },
+                y: { type: 'number' },
+                node: { type: 'string' },
+                resolved: { type: 'boolean' },
+                messages: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        required: ['author', 'text', 'at'],
+                        additionalProperties: false,
+                        properties: {
+                            author: { type: 'string' },
+                            role: { type: 'string', description: 'The role the author held in this root when they wrote it.' },
+                            user: { type: 'string', description: 'The user (alias, else name) from the root\'s settings, when one was known.' },
+                            text: { type: 'string' },
+                            at: { type: 'string', description: 'When, as an ISO 8601 time.' },
+                        },
+                    },
+                },
+            },
+        },
+    },
+};