npm - @oldboydev/sheldon-darwin-arm64 - Versions diffs - 0.2.0 → 0.2.2 - Mend

@oldboydev/sheldon-darwin-arm64 0.2.0 → 0.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2662) hide show

package/node_modules/@sheldon/cli/node_modules/@sheldon/web/dist/server.js CHANGED Viewed

@@ -9,6 +9,7 @@ import { OperationsDatabase } from '@sheldon/persistence';
 import { VaultService, vaultPaths } from '@sheldon/vault';
 import { webOpenApi } from './contract.js';
 import { InvalidWebJobRequestError, WebJobService } from './jobs.js';
+import { listWikiPaths, readRawFile, readWikiPage, WikiNotFoundError } from './wiki.js';
 export async function createWebServer(options) {
     const root = resolve(options.vaultRoot);
     const server = fastify({
@@ -55,6 +56,21 @@ export async function createWebServer(options) {
         const params = request.params;
         return options.application.showEntity(entityKind(params.kind), params.slug);
     });
+    server.get('/api/v1/entities/:kind/:slug/wiki', async (request, reply)=>{
+        const params = request.params;
+        return sendWiki(reply, ()=>listWikiPaths(root, entityKind(params.kind), params.slug));
+    });
+    server.get('/api/v1/entities/:kind/:slug/wiki/*', async (request, reply)=>{
+        const params = request.params;
+        return sendWiki(reply, ()=>readWikiPage(root, entityKind(params.kind), params.slug, params['*']));
+    });
+    server.get('/api/v1/entities/:kind/:slug/raw/*', async (request, reply)=>{
+        const params = request.params;
+        return sendWiki(reply, async ()=>{
+            const text = await readRawFile(root, entityKind(params.kind), params.slug, params['*']);
+            return reply.type('text/plain; charset=utf-8').send(text);
+        });
+    });
     server.post('/api/v1/entities/:kind/:slug/archive', async (request)=>{
         const params = request.params;
         requireConfirmation(request.body, `${params.kind}:${params.slug}`);
@@ -70,6 +86,7 @@ export async function createWebServer(options) {
             tag: query.tag
         });
     });
+    server.get('/api/v1/reviews', async ()=>options.application.listPendingReviews());
     server.get('/api/v1/reviews/:kind/:slug/:proposalId', async (request)=>{
         const params = request.params;
         return options.application.previewProposal(entityKind(params.kind), params.slug, params.proposalId);
@@ -224,6 +241,16 @@ async function dashboard(root) {
         database.close();
     }
 }
+async function sendWiki(reply, run) {
+    try {
+        return await run();
+    } catch (error) {
+        if (error instanceof WikiNotFoundError) {
+            return reply.status(404).send(problem(error.code, error.message, error.target, error.recovery));
+        }
+        throw error;
+    }
+}
 function entityKind(value) {
     if (value === 'topic' || value === 'project') return value;
     throw badRequest('A entidade deve ser topic ou project.');

package/node_modules/@sheldon/cli/node_modules/@sheldon/web/dist/wiki-markdown.js ADDED Viewed

@@ -0,0 +1,75 @@
+export function parseWikiMarkdown(markdown) {
+    const blocks = [];
+    let paragraph = [];
+    const flush = ()=>{
+        if (paragraph.length === 0) return;
+        blocks.push({
+            type: 'paragraph',
+            children: parseInlines(paragraph.join('\n'))
+        });
+        paragraph = [];
+    };
+    for (const line of markdown.replaceAll('\r\n', '\n').split('\n')){
+        const heading = /^(#{1,6})[ \t]+(.+)$/u.exec(line);
+        if (heading) {
+            flush();
+            blocks.push({
+                type: 'heading',
+                level: heading[1].length,
+                children: parseInlines(heading[2])
+            });
+            continue;
+        }
+        if (line.trim() === '') {
+            flush();
+            continue;
+        }
+        paragraph.push(line);
+    }
+    flush();
+    return blocks;
+}
+export function resolveWikiHref(currentPath, href) {
+    const trimmed = href.split('#', 1)[0] ?? href;
+    if (trimmed.startsWith('/') || /^[A-Za-z]:[\\/]/u.test(trimmed) || trimmed.includes('..')) {
+        return trimmed;
+    }
+    const slash = currentPath.replaceAll('\\', '/').lastIndexOf('/');
+    const directory = slash === -1 ? '' : currentPath.slice(0, slash + 1);
+    return `${directory}${trimmed}`.replaceAll(/\/{2,}/gu, '/');
+}
+function parseInlines(text) {
+    const result = [];
+    const expression = /\[([^\]]+)\]\(([^)]+)\)/gu;
+    let last = 0;
+    for (const match of text.matchAll(expression)){
+        const index = match.index ?? 0;
+        if (index > last) result.push({
+            type: 'text',
+            value: text.slice(last, index)
+        });
+        const href = match[2];
+        result.push({
+            type: 'link',
+            href,
+            text: match[1],
+            wiki: isWikiHref(href)
+        });
+        last = index + match[0].length;
+    }
+    if (last < text.length) result.push({
+        type: 'text',
+        value: text.slice(last)
+    });
+    return result.length === 0 ? [
+        {
+            type: 'text',
+            value: text
+        }
+    ] : result;
+}
+function isWikiHref(href) {
+    if (href.length === 0 || href.startsWith('#') || href.startsWith('//')) return false;
+    if (/^[A-Za-z][A-Za-z0-9+.-]*:/u.test(href)) return false;
+    return (href.split('#', 1)[0] ?? href).endsWith('.md');
+}

package/node_modules/@sheldon/cli/node_modules/@sheldon/web/dist/wiki.js ADDED Viewed

@@ -0,0 +1,175 @@
+import { readdir, readFile, realpath, stat } from 'node:fs/promises';
+import { isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { SearchIndex } from '@sheldon/search';
+import { entityDirectory, VaultService } from '@sheldon/vault';
+import { parse } from 'yaml';
+export class WikiNotFoundError extends Error {
+    code = 'WEB_NOT_FOUND';
+    recovery;
+    target;
+    constructor(message, recovery, target){
+        super(message);
+        this.name = 'WikiNotFoundError';
+        this.recovery = recovery;
+        this.target = target;
+    }
+}
+export async function listWikiPaths(vaultRoot, kind, slug) {
+    const entityRoot = await requireEntityRoot(vaultRoot, kind, slug);
+    const wikiRoot = join(entityRoot, 'wiki');
+    const files = await findMarkdownFiles(wikiRoot);
+    return files.map((file)=>({
+            path: toPosix(join('wiki', relative(wikiRoot, file)))
+        })).sort((left, right)=>comparePaths(left.path, right.path));
+}
+export async function readWikiPage(vaultRoot, kind, slug, requestedPath) {
+    const entityRoot = await requireEntityRoot(vaultRoot, kind, slug);
+    const wikiRoot = join(entityRoot, 'wiki');
+    const relativePath = stripPrefix(requestedPath, 'wiki/');
+    const file = await confinedExistingFile(wikiRoot, relativePath);
+    const content = await readFile(file, 'utf8');
+    const concept = parseConcept(content);
+    const realWikiRoot = await realpath(wikiRoot);
+    const path = toPosix(join('wiki', relative(realWikiRoot, file)));
+    return {
+        ...concept,
+        path,
+        neighbours: await readNeighbours(vaultRoot, kind, slug, path)
+    };
+}
+export async function readRawFile(vaultRoot, kind, slug, requestedPath) {
+    const entityRoot = await requireEntityRoot(vaultRoot, kind, slug);
+    const rawRoot = join(entityRoot, 'raw');
+    const relativePath = stripPrefix(requestedPath, 'raw/');
+    const file = await confinedExistingFile(rawRoot, relativePath);
+    return readFile(file, 'utf8');
+}
+async function requireEntityRoot(vaultRoot, kind, slug) {
+    const vault = await VaultService.discover(vaultRoot);
+    try {
+        await vault.inspectEntity(kind, slug);
+    } catch  {
+        throw new WikiNotFoundError('Entidade não encontrada.', 'Atualize a lista e tente novamente.', `${kind}/${slug}`);
+    }
+    return entityDirectory(vaultRoot, kind, slug);
+}
+async function confinedExistingFile(root, requestedPath) {
+    const target = confinedPath(root, requestedPath);
+    let realRoot;
+    let realTarget;
+    try {
+        realRoot = await realpath(root);
+        realTarget = await realpath(target);
+    } catch  {
+        throw wikiMissing();
+    }
+    if (!isInside(realRoot, realTarget)) throw wikiMissing();
+    const info = await stat(realTarget);
+    if (!info.isFile()) throw wikiMissing();
+    return realTarget;
+}
+function confinedPath(root, requestedPath) {
+    const trimmed = requestedPath.trim();
+    if (trimmed.length === 0 || trimmed.includes('\0') || isAbsolute(trimmed)) {
+        throw wikiMissing();
+    }
+    const target = resolve(root, trimmed);
+    if (!isInside(root, target)) throw wikiMissing();
+    return target;
+}
+function isInside(root, target) {
+    const relativePath = relative(resolve(root), resolve(target));
+    return relativePath !== '' && relativePath !== '..' && !relativePath.startsWith(`..${sep}`) && !isAbsolute(relativePath);
+}
+async function findMarkdownFiles(root) {
+    const found = [];
+    const visit = async (directory)=>{
+        let entries;
+        try {
+            entries = await readdir(directory, {
+                withFileTypes: true
+            });
+        } catch (error) {
+            if (isMissing(error)) return;
+            throw error;
+        }
+        for (const entry of entries){
+            const path = join(directory, entry.name);
+            if (entry.isDirectory()) await visit(path);
+            else if (entry.isFile() && entry.name.endsWith('.md')) found.push(path);
+        }
+    };
+    await visit(root);
+    return found;
+}
+function parseConcept(content) {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/u.exec(content);
+    let data = {};
+    let body = content;
+    if (match) {
+        const value = parse(match[1]);
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            data = value;
+        }
+        body = content.slice(match[0].length).replace(/^\r?\n/u, '');
+    }
+    return {
+        id: typeof data.id === 'string' ? data.id : '',
+        title: typeof data.title === 'string' ? data.title : '',
+        sources: Array.isArray(data.sources) ? data.sources.filter((item)=>typeof item === 'string') : [],
+        body
+    };
+}
+async function readNeighbours(vaultRoot, kind, slug, path) {
+    let index;
+    try {
+        index = SearchIndex.open(vaultRoot);
+    } catch  {
+        return [];
+    }
+    try {
+        const neighbours = [];
+        for (const relation of index.findRelatedConcepts({
+            kind,
+            slug
+        }, path)){
+            for (const mapped of mapRelation(relation.relation)){
+                neighbours.push({
+                    path: relation.path,
+                    relation: mapped
+                });
+            }
+        }
+        return neighbours;
+    } finally{
+        index.close();
+    }
+}
+function mapRelation(relation) {
+    if (relation === 'outgoing') return [
+        'outgoing'
+    ];
+    if (relation === 'backlink') return [
+        'incoming'
+    ];
+    return [
+        'outgoing',
+        'incoming'
+    ];
+}
+function stripPrefix(path, prefix) {
+    const normalized = path.replaceAll('\\', '/');
+    return normalized.startsWith(prefix) ? normalized.slice(prefix.length) : normalized;
+}
+function toPosix(path) {
+    return path.replaceAll('\\', '/');
+}
+function comparePaths(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function wikiMissing() {
+    return new WikiNotFoundError('Wiki não encontrado.', 'Atualize a lista e tente novamente.', 'Wiki');
+}
+function isMissing(error) {
+    return error instanceof Error && 'code' in error && error.code === 'ENOENT';
+}

package/node_modules/@sheldon/cli/node_modules/@sheldon/web/node_modules/@fastify/static/node_modules/glob/node_modules/path-scurry/node_modules/lru-cache/dist/commonjs/react-native/diagnostics-channel-react-native.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"diagnostics-channel-react-native.d.ts","sourceRoot":"","sources":["../../../src/diagnostics-channel-react-native.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,cAAc,EACpB,MAAM,0BAA0B,CAAA;AACjC,YAAY,EAAE,cAAc,EAAE,OAAO,EAAE,CAAA;AAGvC,eAAO,MAAM,OAAO,EAAY,OAAO,CAAC,OAAO,CAAC,CAAA;AAChD,eAAO,MAAM,OAAO,EAAY,cAAc,CAAC,OAAO,CAAC,CAAA"}

@@ -0,0 +1 @@

+ {"version":3,"file":"diagnostics-channel-react-native.js","sourceRoot":"","sources":["../../../src/diagnostics-channel-react-native.ts"],"names":[],"mappings":";;;AAQA,MAAM,KAAK,GAAG,EAAE,cAAc,EAAE,KAAK,EAAE,CAAA;AAC1B,QAAA,OAAO,GAAG,KAAyB,CAAA;AACnC,QAAA,OAAO,GAAG,KAAgC,CAAA","sourcesContent":["// this is used in ESM environments that follow the 'react-native' import\n// condition, to avoid even trying to load node:diagnostics_channel\nimport {\n type Channel,\n type TracingChannel,\n} from 'node:diagnostics_channel'\nexport type { TracingChannel, Channel }\n\nconst dummy = { hasSubscribers: false }\nexport const metrics = dummy as Channel<unknown>\nexport const tracing = dummy as TracingChannel<unknown>\n"]}

@@ -0,0 +1,5 @@
+import { type Channel, type TracingChannel } from 'node:diagnostics_channel';
+export type { TracingChannel, Channel };
+export declare const metrics: Channel<unknown>;
+export declare const tracing: TracingChannel<unknown>;
+//# sourceMappingURL=diagnostics-channel-react-native.d.ts.map

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tracing = exports.metrics = void 0;
+const dummy = { hasSubscribers: false };
+exports.metrics = dummy;
+exports.tracing = dummy;
+//# sourceMappingURL=diagnostics-channel-react-native.js.map