@gjsify/site 0.64.11 → 0.64.12-next.279

package/lib/site-data/frontmatter.js

@@ -0,0 +1,242 @@
+function stripBom(text) {
+    if (text.charCodeAt(0) === 0xfeff) {
+        return text.slice(1);
+    }
+    return text;
+}
+function unescapeDoubleQuoted(value) {
+    let result = '';
+    for (let i = 0; i < value.length; i++) {
+        const ch = value[i];
+        if (ch === '\\' && i + 1 < value.length) {
+            const next = value[i + 1];
+            if (next === '"') {
+                result += '"';
+                i++;
+                continue;
+            }
+            if (next === '\\') {
+                result += '\\';
+                i++;
+                continue;
+            }
+            if (next === 'n') {
+                result += '\n';
+                i++;
+                continue;
+            }
+            // For other escapes, keep as-is per common YAML subset behavior? Spec says double supports \" \\ \n escapes
+            result += '\\' + next;
+            i++;
+            continue;
+        }
+        result += ch;
+    }
+    return result;
+}
+function parseScalar(value, file, lineNumber) {
+    const trimmed = value.trim();
+    if (trimmed === '') {
+        // Will be handled by caller for dash lists
+        return trimmed;
+    }
+    if (trimmed === 'true') {
+        return true;
+    }
+    if (trimmed === 'false') {
+        return false;
+    }
+    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+        const inner = trimmed.slice(1, -1).trim();
+        if (inner === '') {
+            return [];
+        }
+        const result = [];
+        // Simple parser for inline lists
+        let current = '';
+        let inSingle = false;
+        let inDouble = false;
+        for (let i = 0; i < inner.length; i++) {
+            const ch = inner[i];
+            if (inDouble) {
+                if (ch === '\\' && i + 1 < inner.length) {
+                    current += ch + inner[i + 1];
+                    i++;
+                    continue;
+                }
+                if (ch === '"') {
+                    inDouble = false;
+                    current += ch;
+                    continue;
+                }
+                current += ch;
+                continue;
+            }
+            if (inSingle) {
+                if (ch === "'" && i + 1 < inner.length && inner[i + 1] === "'") {
+                    current += "''";
+                    i++;
+                    continue;
+                }
+                if (ch === "'") {
+                    inSingle = false;
+                    current += ch;
+                    continue;
+                }
+                current += ch;
+                continue;
+            }
+            if (ch === '"') {
+                inDouble = true;
+                current += ch;
+                continue;
+            }
+            if (ch === "'") {
+                inSingle = true;
+                current += ch;
+                continue;
+            }
+            if (ch === ',') {
+                result.push(parseScalar(current, file, lineNumber));
+                current = '';
+                continue;
+            }
+            current += ch;
+        }
+        if (current.trim() !== '') {
+            result.push(parseScalar(current, file, lineNumber));
+        }
+        // Ensure all are strings
+        return result.map((r) => String(r));
+    }
+    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        if (trimmed.length < 2) {
+            throw new Error(`${file}:${lineNumber}: unclosed quotes`);
+        }
+        // Check for unclosed
+        // Simple check - count unescaped quotes
+        const inner = trimmed.slice(1, -1);
+        // Validate escapes roughly
+        return unescapeDoubleQuoted(inner);
+    }
+    if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
+        if (trimmed.length < 2) {
+            throw new Error(`${file}:${lineNumber}: unclosed quotes`);
+        }
+        const inner = trimmed.slice(1, -1);
+        // single supports ''
+        return inner.replace(/''/g, "'");
+    }
+    // Plain scalar
+    return trimmed;
+}
+/** `file` is only used in error messages. Text without a leading `---` line has empty data and the whole text as body. */
+export function parseFrontmatter(text, file) {
+    let normalized = stripBom(text).replace(/\r\n/g, '\n');
+    if (!normalized.startsWith('---')) {
+        return { data: {}, body: text.replace(/\r\n/g, '\n') };
+    }
+    // Find closing ---
+    const lines = normalized.split('\n');
+    if (lines[0]?.trim() !== '---') {
+        return { data: {}, body: text.replace(/\r\n/g, '\n') };
+    }
+    let endIndex = -1;
+    for (let i = 1; i < lines.length; i++) {
+        if (lines[i]?.trim() === '---') {
+            endIndex = i;
+            break;
+        }
+    }
+    if (endIndex === -1) {
+        throw new Error(`${file}: missing closing ---`);
+    }
+    const data = {};
+    const seenKeys = new Set();
+    for (let i = 1; i < endIndex; i++) {
+        const line = lines[i];
+        const lineNumber = i + 1; // 1-based relative to start of file for error messages
+        // Skip blank lines and comments
+        const trimmed = line.trim();
+        if (trimmed === '' || trimmed.startsWith('#')) {
+            continue;
+        }
+        // Check for dash list item
+        if (line.match(/^\s*-\s+/)) {
+            // This would mean we're in a list - but we need to track context
+            // For our subset, dash list comes after empty value
+            continue;
+        }
+        const colonIndex = line.indexOf(':');
+        if (colonIndex === -1) {
+            throw new Error(`${file}:${lineNumber}: invalid line`);
+        }
+        const key = line.slice(0, colonIndex).trim();
+        if (key === '') {
+            throw new Error(`${file}:${lineNumber}: invalid key`);
+        }
+        if (seenKeys.has(key)) {
+            throw new Error(`${file}:${lineNumber}: duplicate key ${key}`);
+        }
+        const valuePart = line.slice(colonIndex + 1);
+        // Check if empty value followed by dash list
+        if (valuePart.trim() === '') {
+            // Look ahead for dash list items
+            const items = [];
+            let j = i + 1;
+            while (j < endIndex) {
+                const nextLine = lines[j];
+                const nextTrimmed = nextLine.trim();
+                if (nextTrimmed === '' || nextTrimmed.startsWith('#')) {
+                    j++;
+                    continue;
+                }
+                if (nextLine.match(/^\s*-\s+/)) {
+                    const itemContent = nextLine.replace(/^\s*-\s+/, '').trim();
+                    // Item could be quoted or plain
+                    if (itemContent.startsWith('"') && itemContent.endsWith('"')) {
+                        items.push(unescapeDoubleQuoted(itemContent.slice(1, -1)));
+                    }
+                    else if (itemContent.startsWith("'") && itemContent.endsWith("'")) {
+                        items.push(itemContent.slice(1, -1).replace(/''/g, "'"));
+                    }
+                    else {
+                        items.push(itemContent);
+                    }
+                    j++;
+                    continue;
+                }
+                break;
+            }
+            if (items.length > 0) {
+                data[key] = items;
+                seenKeys.add(key);
+                i = j - 1;
+                continue;
+            }
+            else {
+                // Empty value with nothing after - could be error or just empty? But spec says "empty value followed by dash list lines" gives string[]
+                // If no dash list follows, maybe treat as empty string or error? Let us look up - but be conservative
+                throw new Error(`${file}:${lineNumber}: invalid value`);
+            }
+        }
+        // Parse scalar value
+        // Numbers and dates stay strings: the post decides what they mean.
+        data[key] = parseScalar(valuePart, file, lineNumber);
+        seenKeys.add(key);
+    }
+    // Body = everything after the closing delimiter with ONE leading newline removed
+    let body = '';
+    if (endIndex + 1 < lines.length) {
+        const bodyLines = lines.slice(endIndex + 1);
+        body = bodyLines.join('\n');
+        // Remove ONE leading newline if present
+        if (body.startsWith('\n')) {
+            body = body.slice(1);
+        }
+        else if (body.startsWith('\r\n')) {
+            body = body.slice(2);
+        }
+    }
+    return { data, body };
+}

package/lib/site-data/index.d.ts

@@ -1,6 +1,9 @@
+export * from './blog.js';
 export * from './config.js';
+export * from './developer.js';
 export * from './downloads.js';
 export * from './flathub.js';
+export * from './frontmatter.js';
 export * from './github.js';
 export * from './load.js';
 export * from './metainfo.js';
@@ -10,6 +13,7 @@ export * from './oars.js';
 export * from './po.js';
 export * from './privacy.js';
 export * from './related.js';
+export * from './resume.js';
 export * from './screenshots.js';
 export * from './sepa.js';
 export * from './types.js';

package/lib/site-data/index.js

@@ -1,6 +1,9 @@
+export * from './blog.js';
 export * from './config.js';
+export * from './developer.js';
 export * from './downloads.js';
 export * from './flathub.js';
+export * from './frontmatter.js';
 export * from './github.js';
 export * from './load.js';
 export * from './metainfo.js';
@@ -10,6 +13,7 @@ export * from './oars.js';
 export * from './po.js';
 export * from './privacy.js';
 export * from './related.js';
+export * from './resume.js';
 export * from './screenshots.js';
 export * from './sepa.js';
 export * from './types.js';

package/lib/site-data/related.d.ts

@@ -1,5 +1,5 @@
 import { type NetworkOptions } from './network.js';
-import type { AppManifest, RelatedApp, SiteConfig, SiteData } from './types.js';
+import type { AppManifest, RelatedApp, SiteConfig, SiteData, SiteRelatedAppConfig } from './types.js';
 /** Where a site publishes its `app.json`. */
 export declare const APP_MANIFEST_FILE = "app.json";
 /** The `app.json` of a site: what another site needs to list this app. Icon URL is absolute. */
@@ -12,9 +12,11 @@ export interface RelatedAppsOptions {
     network?: NetworkOptions;
     warn: (message: string) => void;
 }
+/** Resolves app entries in order — `relatedApps`, or a developer's `apps`. Never throws: an entry that cannot be had is skipped with a warning. */
+export declare function loadAppEntries(entries: readonly SiteRelatedAppConfig[], options: RelatedAppsOptions): Promise<RelatedApp[]>;
 /**
  * Resolves `gjsify.site.relatedApps` in configured order. The site's own entry is dropped, so every
- * app can share one list. Never throws: an entry that cannot be had is skipped with a warning.
+ * app can share one list.
  */
 export declare function loadRelatedApps(config: SiteConfig, ownId: string, options: RelatedAppsOptions): Promise<RelatedApp[]>;
 /** A text in the reader's language, else English, else whatever the app has. */

package/lib/site-data/related.js

@@ -81,14 +81,19 @@ async function loadOne(entry, options) {
         return undefined;
     }
 }
+/** Resolves app entries in order — `relatedApps`, or a developer's `apps`. Never throws: an entry that cannot be had is skipped with a warning. */
+export async function loadAppEntries(entries, options) {
+    const loaded = await Promise.all(entries.map((entry) => loadOne(entry, options)));
+    return loaded.filter((app) => app !== undefined);
+}
 /**
  * Resolves `gjsify.site.relatedApps` in configured order. The site's own entry is dropped, so every
- * app can share one list. Never throws: an entry that cannot be had is skipped with a warning.
+ * app can share one list.
  */
 export async function loadRelatedApps(config, ownId, options) {
     const candidates = config.relatedApps.filter((entry) => !sameUrl(entry.url, config.url));
-    const loaded = await Promise.all(candidates.map((entry) => loadOne(entry, options)));
-    return loaded.filter((app) => app !== undefined && app.id !== ownId && !sameUrl(app.url, config.url));
+    const loaded = await loadAppEntries(candidates, options);
+    return loaded.filter((app) => app.id !== ownId && !sameUrl(app.url, config.url));
 }
 /** A text in the reader's language, else English, else whatever the app has. */
 export function relatedText(text, lang) {

package/lib/site-data/resume.d.ts

@@ -0,0 +1,64 @@
+export interface ResumeProfile {
+    network: string;
+    username?: string;
+    url?: string;
+}
+export interface ResumeBasics {
+    name: string;
+    label?: string;
+    image?: string;
+    email?: string;
+    url?: string;
+    summary?: string;
+    location?: {
+        city?: string;
+        region?: string;
+        countryCode?: string;
+    };
+    profiles: ResumeProfile[];
+}
+export interface ResumeWork {
+    name: string;
+    position?: string;
+    url?: string;
+    startDate?: string;
+    endDate?: string;
+    summary?: string;
+    highlights: string[];
+    location?: string;
+}
+export interface ResumeEducation {
+    institution: string;
+    area?: string;
+    studyType?: string;
+    url?: string;
+    startDate?: string;
+    endDate?: string;
+}
+export interface ResumeSkill {
+    name: string;
+    keywords: string[];
+}
+export interface ResumeLanguage {
+    language: string;
+    fluency?: string;
+}
+export interface ResumeProject {
+    name: string;
+    description?: string;
+    url?: string;
+    startDate?: string;
+    endDate?: string;
+    highlights: string[];
+    keywords: string[];
+}
+export interface Resume {
+    basics: ResumeBasics;
+    work: ResumeWork[];
+    education: ResumeEducation[];
+    skills: ResumeSkill[];
+    languages: ResumeLanguage[];
+    projects: ResumeProject[];
+}
+export declare function parseResume(raw: unknown, file: string): Resume;
+export declare function loadResume(path: string): Promise<Resume>;

package/lib/site-data/resume.js

@@ -0,0 +1,277 @@
+import { readFile } from 'node:fs/promises';
+const isRecord = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+function validateDateString(value, file, path) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`${file}: ${path} must be a string`);
+    }
+    // Empty strings for optional fields are treated as absent
+    if (value === '') {
+        return undefined;
+    }
+    // JSON-Resume form (YYYY, YYYY-MM or YYYY-MM-DD)
+    if (/^\d{4}$/.test(value) || /^\d{4}-\d{2}$/.test(value) || /^\d{4}-\d{2}-\d{2}$/.test(value)) {
+        return value;
+    }
+    throw new Error(`${file}: ${path} "${value}" is not YYYY, YYYY-MM or YYYY-MM-DD`);
+}
+function validateString(value, file, path) {
+    if (typeof value !== 'string') {
+        throw new Error(`${file}: ${path} must be a string`);
+    }
+    return value;
+}
+function validateOptionalString(value, file, path) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`${file}: ${path} must be a string`);
+    }
+    if (value === '') {
+        return undefined;
+    }
+    return value;
+}
+export function parseResume(raw, file) {
+    if (!isRecord(raw)) {
+        throw new Error(`${file}: invalid resume`);
+    }
+    if (!isRecord(raw.basics)) {
+        throw new Error(`${file}: basics must be an object`);
+    }
+    const basicsRaw = raw.basics;
+    const basicsName = validateString(basicsRaw.name, file, 'basics.name');
+    const basics = {
+        name: basicsName,
+        label: validateOptionalString(basicsRaw.label, file, 'basics.label'),
+        image: validateOptionalString(basicsRaw.image, file, 'basics.image'),
+        email: validateOptionalString(basicsRaw.email, file, 'basics.email'),
+        url: validateOptionalString(basicsRaw.url, file, 'basics.url'),
+        summary: validateOptionalString(basicsRaw.summary, file, 'basics.summary'),
+        location: undefined,
+        profiles: [],
+    };
+    if (basicsRaw.location !== undefined && basicsRaw.location !== null) {
+        if (!isRecord(basicsRaw.location)) {
+            throw new Error(`${file}: basics.location must be an object`);
+        }
+        const loc = basicsRaw.location;
+        basics.location = {
+            city: validateOptionalString(loc.city, file, 'basics.location.city'),
+            region: validateOptionalString(loc.region, file, 'basics.location.region'),
+            countryCode: validateOptionalString(loc.countryCode, file, 'basics.location.countryCode'),
+        };
+    }
+    if (basicsRaw.profiles !== undefined && basicsRaw.profiles !== null) {
+        if (!Array.isArray(basicsRaw.profiles)) {
+            throw new Error(`${file}: basics.profiles must be an array`);
+        }
+        for (let i = 0; i < basicsRaw.profiles.length; i++) {
+            const p = basicsRaw.profiles[i];
+            if (!isRecord(p)) {
+                throw new Error(`${file}: basics.profiles[${i}] must be an object`);
+            }
+            if (typeof p.network !== 'string') {
+                throw new Error(`${file}: basics.profiles[${i}].network must be a string`);
+            }
+            basics.profiles.push({
+                network: p.network,
+                username: validateOptionalString(p.username, file, `basics.profiles[${i}].username`),
+                url: validateOptionalString(p.url, file, `basics.profiles[${i}].url`),
+            });
+        }
+    }
+    else {
+        basics.profiles = [];
+    }
+    const work = [];
+    if (raw.work !== undefined && raw.work !== null) {
+        if (!Array.isArray(raw.work)) {
+            throw new Error(`${file}: work must be an array`);
+        }
+        for (let i = 0; i < raw.work.length; i++) {
+            const w = raw.work[i];
+            if (!isRecord(w)) {
+                throw new Error(`${file}: work[${i}] must be an object`);
+            }
+            if (typeof w.name !== 'string') {
+                throw new Error(`${file}: work[${i}].name must be a string`);
+            }
+            const highlights = [];
+            if (w.highlights !== undefined && w.highlights !== null) {
+                if (!Array.isArray(w.highlights)) {
+                    throw new Error(`${file}: work[${i}].highlights must be an array`);
+                }
+                for (const h of w.highlights) {
+                    if (typeof h !== 'string') {
+                        throw new Error(`${file}: work[${i}].highlights must contain strings`);
+                    }
+                    highlights.push(h);
+                }
+            }
+            work.push({
+                name: w.name,
+                position: validateOptionalString(w.position, file, `work[${i}].position`),
+                url: validateOptionalString(w.url, file, `work[${i}].url`),
+                startDate: validateDateString(w.startDate, file, `work[${i}].startDate`),
+                endDate: validateDateString(w.endDate, file, `work[${i}].endDate`),
+                summary: validateOptionalString(w.summary, file, `work[${i}].summary`),
+                highlights,
+                location: validateOptionalString(w.location, file, `work[${i}].location`),
+            });
+        }
+    }
+    const education = [];
+    if (raw.education !== undefined && raw.education !== null) {
+        if (!Array.isArray(raw.education)) {
+            throw new Error(`${file}: education must be an array`);
+        }
+        for (let i = 0; i < raw.education.length; i++) {
+            const e = raw.education[i];
+            if (!isRecord(e)) {
+                throw new Error(`${file}: education[${i}] must be an object`);
+            }
+            if (typeof e.institution !== 'string') {
+                throw new Error(`${file}: education[${i}].institution must be a string`);
+            }
+            education.push({
+                institution: e.institution,
+                area: validateOptionalString(e.area, file, `education[${i}].area`),
+                studyType: validateOptionalString(e.studyType, file, `education[${i}].studyType`),
+                url: validateOptionalString(e.url, file, `education[${i}].url`),
+                startDate: validateDateString(e.startDate, file, `education[${i}].startDate`),
+                endDate: validateDateString(e.endDate, file, `education[${i}].endDate`),
+            });
+        }
+    }
+    const skills = [];
+    if (raw.skills !== undefined && raw.skills !== null) {
+        if (!Array.isArray(raw.skills)) {
+            throw new Error(`${file}: skills must be an array`);
+        }
+        for (let i = 0; i < raw.skills.length; i++) {
+            const s = raw.skills[i];
+            if (!isRecord(s)) {
+                throw new Error(`${file}: skills[${i}] must be an object`);
+            }
+            if (typeof s.name !== 'string') {
+                throw new Error(`${file}: skills[${i}].name must be a string`);
+            }
+            const keywords = [];
+            if (s.keywords !== undefined && s.keywords !== null) {
+                if (!Array.isArray(s.keywords)) {
+                    throw new Error(`${file}: skills[${i}].keywords must be an array`);
+                }
+                for (const k of s.keywords) {
+                    if (typeof k !== 'string') {
+                        throw new Error(`${file}: skills[${i}].keywords must contain strings`);
+                    }
+                    keywords.push(k);
+                }
+            }
+            skills.push({
+                name: s.name,
+                keywords,
+            });
+        }
+    }
+    const languages = [];
+    if (raw.languages !== undefined && raw.languages !== null) {
+        if (!Array.isArray(raw.languages)) {
+            throw new Error(`${file}: languages must be an array`);
+        }
+        for (let i = 0; i < raw.languages.length; i++) {
+            const l = raw.languages[i];
+            if (!isRecord(l)) {
+                throw new Error(`${file}: languages[${i}] must be an object`);
+            }
+            if (typeof l.language !== 'string') {
+                throw new Error(`${file}: languages[${i}].language must be a string`);
+            }
+            languages.push({
+                language: l.language,
+                fluency: validateOptionalString(l.fluency, file, `languages[${i}].fluency`),
+            });
+        }
+    }
+    const projects = [];
+    if (raw.projects !== undefined && raw.projects !== null) {
+        if (!Array.isArray(raw.projects)) {
+            throw new Error(`${file}: projects must be an array`);
+        }
+        for (let i = 0; i < raw.projects.length; i++) {
+            const pr = raw.projects[i];
+            if (!isRecord(pr)) {
+                throw new Error(`${file}: projects[${i}] must be an object`);
+            }
+            if (typeof pr.name !== 'string') {
+                throw new Error(`${file}: projects[${i}].name must be a string`);
+            }
+            const highlights = [];
+            if (pr.highlights !== undefined && pr.highlights !== null) {
+                if (!Array.isArray(pr.highlights)) {
+                    throw new Error(`${file}: projects[${i}].highlights must be an array`);
+                }
+                for (const h of pr.highlights) {
+                    if (typeof h !== 'string') {
+                        throw new Error(`${file}: projects[${i}].highlights must contain strings`);
+                    }
+                    highlights.push(h);
+                }
+            }
+            const keywords = [];
+            if (pr.keywords !== undefined && pr.keywords !== null) {
+                if (!Array.isArray(pr.keywords)) {
+                    throw new Error(`${file}: projects[${i}].keywords must be an array`);
+                }
+                for (const k of pr.keywords) {
+                    if (typeof k !== 'string') {
+                        throw new Error(`${file}: projects[${i}].keywords must contain strings`);
+                    }
+                    keywords.push(k);
+                }
+            }
+            projects.push({
+                name: pr.name,
+                description: validateOptionalString(pr.description, file, `projects[${i}].description`),
+                url: validateOptionalString(pr.url, file, `projects[${i}].url`),
+                startDate: validateDateString(pr.startDate, file, `projects[${i}].startDate`),
+                endDate: validateDateString(pr.endDate, file, `projects[${i}].endDate`),
+                highlights,
+                keywords,
+            });
+        }
+    }
+    return {
+        basics,
+        work,
+        education,
+        skills,
+        languages,
+        projects,
+    };
+}
+export async function loadResume(path) {
+    try {
+        const content = await readFile(path, 'utf-8');
+        let raw;
+        try {
+            raw = JSON.parse(content);
+        }
+        catch (e) {
+            throw new Error(`${path}: ${String(e)}`);
+        }
+        return parseResume(raw, path);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            throw e;
+        }
+        throw new Error(`${path}: ${String(e)}`);
+    }
+}