structured-context 0.10.0 → 0.12.0

package/dist/read/wikilink-utils.js

@@ -1,3 +1,43 @@
+/**
+ * Format a wikilink string.
+ * formatWikilink('My Goal') -> '[[My Goal]]'
+ * formatWikilink('My Goal', 'Custom Display') -> '[[My Goal|Custom Display]]'
+ */
+export function formatWikilink(target, alias) {
+    const trimmedTarget = target.trim();
+    const trimmedAlias = alias?.trim();
+    if (trimmedAlias && trimmedAlias !== trimmedTarget) {
+        return `[[${trimmedTarget}|${trimmedAlias}]]`;
+    }
+    return `[[${trimmedTarget}]]`;
+}
+/**
+ * Parse a wikilink or link inner string into target, anchor, and displayText.
+ * Handles: [[target]], [[target#anchor]], [[target|alias]], [[target#anchor|alias]]
+ * Also handles bare forms without enclosing brackets.
+ */
+export function parseWikilink(wikilink) {
+    const cleaned = wikilink.replace(/^"|"$/g, '').trim();
+    const inner = cleaned.startsWith('[[') && cleaned.endsWith(']]') ? cleaned.slice(2, -2).trim() : cleaned;
+    // Alias: [[target|alias]] or [[target#anchor|alias]]
+    const pipeIdx = inner.indexOf('|');
+    let core = inner;
+    let displayText;
+    if (pipeIdx >= 0) {
+        core = inner.slice(0, pipeIdx);
+        const alias = inner.slice(pipeIdx + 1).trim();
+        if (alias)
+            displayText = alias;
+    }
+    // Anchor: [[target#anchor]] or [[target#^block]]
+    const hashIdx = core.indexOf('#');
+    if (hashIdx >= 0) {
+        const target = core.slice(0, hashIdx).trim();
+        const anchor = core.slice(hashIdx + 1).trim() || undefined;
+        return { target, anchor, displayText };
+    }
+    return { target: core.trim(), displayText };
+}
 /**
  * Extract the lookup key from a wikilink string such as:
  *   [[Personal Vision]]                → "Personal Vision"

package/dist/render/render.d.ts

@@ -1,4 +1,7 @@
+import { type RenderResult } from '../plugins/util';
 import type { SpaceContext } from '../types';
 export declare function executeRender(formatName: string, context: SpaceContext, options: {
     filter?: string;
-}): Promise<string>;
+    hierarchy?: string;
+    data?: Record<string, unknown>;
+}): Promise<RenderResult>;

package/dist/render/render.js

@@ -1,7 +1,7 @@
-import { filterNodes } from '../filter/filter-nodes';
+import { shortenPluginName } from '../plugins/util';
+import { updateSpaceField } from '../config';
+import { assembleSpaceGraph } from '../load-space-graph';
 import { loadPlugins } from '../plugins/loader';
-import { readSpace } from '../read/read-space';
-import { buildSpaceGraph } from '../space-graph';
 import { buildFormatRegistry } from './registry';
 export async function executeRender(formatName, context, options) {
     const pluginMap = context.space?.plugins ?? {};
@@ -12,17 +12,21 @@ export async function executeRender(formatName, context, options) {
         const available = registry.map((r) => r.qualifiedName).join(', ');
         throw new Error(`Unknown render format: "${formatName}".${available ? ` Available: ${available}` : ' No formats registered.'}`);
     }
-    const { nodes: allNodes } = await readSpace(context);
-    // Validate: drop nodes that fail schema validation
-    const { schemaValidator } = context;
-    const validNodes = allNodes.filter((node) => schemaValidator(node.schemaData));
-    const levels = context.schema.metadata.hierarchy?.levels ?? [];
-    let graph = buildSpaceGraph(validNodes, levels);
-    // Filter: apply filter expression if provided
-    if (options.filter) {
-        const expression = context.space.views?.[options.filter]?.expression ?? options.filter;
-        graph = await filterNodes(expression, graph);
-    }
-    const pluginContext = { ...context, pluginConfig: entry.plugin.pluginConfig };
-    return entry.plugin.plugin.render.render(pluginContext, graph, { format: entry.format.name });
+    const graph = await assembleSpaceGraph(context, { filter: options.filter, hierarchy: options.hierarchy });
+    const shortName = shortenPluginName(entry.plugin.plugin.name);
+    const pluginContext = {
+        ...context,
+        pluginConfig: entry.plugin.pluginConfig,
+        callbacks: {
+            persistConfig: (updates) => {
+                for (const [field, value] of Object.entries(updates)) {
+                    updateSpaceField(context.space.name, field, value, shortName);
+                }
+            },
+        },
+    };
+    return entry.plugin.plugin.render.render(pluginContext, graph, {
+        format: entry.format.name,
+        data: options.data,
+    });
 }

package/dist/schema/evaluate-rule.js

@@ -52,6 +52,7 @@ function flattenNode(node) {
         resolvedType: node.resolvedType,
         resolvedParentTitle: node.resolvedParents[0]?.title, // first parent or undefined, provided for convenience
         resolvedParentTitles: node.resolvedParents.map((r) => r.title), // full array of parent titles
+        resolvedLinks: node.resolvedLinks,
     };
 }
 /**

package/dist/schema/meta-schemas.d.ts

@@ -0,0 +1,13 @@
+import type { AnySchemaObject } from 'ajv';
+/** Version folders under `generatedDir` (named after the release that first shipped the dialect), oldest first. */
+export declare function listMetaVersions(generatedDir: string): string[];
+/** The newest released meta-schema and its version folder, if any. */
+export declare function readNewestMetaSchema(generatedDir: string): {
+    version: string;
+    schema: AnySchemaObject;
+} | undefined;
+/**
+ * Meta-schemas shipped in `<schemasDir>/generated/`, keyed by `$id`: every versioned folder at its own `$id`, and
+ * `latest` registered under the `latest` URL so `$schema` references to either form resolve.
+ */
+export declare function loadMetaSchemas(schemasDir: string): Map<string, AnySchemaObject>;

package/dist/schema/meta-schemas.js

@@ -0,0 +1,50 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { SCHEMA_META_FILE, SCHEMA_META_ID } from './metadata-contract';
+const LATEST_FOLDER = 'latest';
+const VERSION_FOLDER = /^\d+\.\d+\.\d+$/;
+function compareVersions(a, b) {
+    const [pa, pb] = [a, b].map((v) => v.split('.').map(Number));
+    for (let i = 0; i < 3; i++) {
+        const diff = (pa?.[i] ?? 0) - (pb?.[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+/** Version folders under `generatedDir` (named after the release that first shipped the dialect), oldest first. */
+export function listMetaVersions(generatedDir) {
+    if (!existsSync(generatedDir))
+        return [];
+    return readdirSync(generatedDir)
+        .filter((name) => VERSION_FOLDER.test(name))
+        .sort(compareVersions);
+}
+function readMetaSchema(generatedDir, folder) {
+    const path = join(generatedDir, folder, SCHEMA_META_FILE);
+    return existsSync(path) ? JSON.parse(readFileSync(path, 'utf-8')) : undefined;
+}
+/** The newest released meta-schema and its version folder, if any. */
+export function readNewestMetaSchema(generatedDir) {
+    const version = listMetaVersions(generatedDir).at(-1);
+    const schema = version && readMetaSchema(generatedDir, version);
+    return version && schema ? { version, schema } : undefined;
+}
+/**
+ * Meta-schemas shipped in `<schemasDir>/generated/`, keyed by `$id`: every versioned folder at its own `$id`, and
+ * `latest` registered under the `latest` URL so `$schema` references to either form resolve.
+ */
+export function loadMetaSchemas(schemasDir) {
+    const generatedDir = join(schemasDir, 'generated');
+    const schemas = new Map();
+    for (const version of listMetaVersions(generatedDir)) {
+        const schema = readMetaSchema(generatedDir, version);
+        if (schema && typeof schema.$id === 'string')
+            schemas.set(schema.$id, schema);
+    }
+    // The `latest` copy carries its versioned `$id`, which a version folder may already own; register it under its own URL.
+    const latest = readMetaSchema(generatedDir, LATEST_FOLDER);
+    if (latest)
+        schemas.set(SCHEMA_META_ID, { ...latest, $id: SCHEMA_META_ID });
+    return schemas;
+}