@openforge-app/plugin-sdk 0.2.9 → 0.2.11

package/dist/publicEntrypoints.d.mts

@@ -0,0 +1,27 @@
+export type OpenForgePluginSdkConditionalExport = Readonly<{
+  types: `./dist/${string}.d.ts`
+  default: `./dist/${string}.js`
+}>
+
+export type OpenForgePluginSdkPublicEntrypoint = Readonly<{
+  packageSubpath: '.' | `./${string}`
+  importSpecifier: '@openforge-app/plugin-sdk' | `@openforge-app/plugin-sdk/${string}`
+  sourcePath: `src/${string}`
+  workspaceSourcePath: `packages/plugin-sdk/src/${string}`
+  packageExport: string | OpenForgePluginSdkConditionalExport
+}>
+
+export const OPENFORGE_PLUGIN_SDK_PUBLIC_ENTRYPOINTS: readonly OpenForgePluginSdkPublicEntrypoint[]
+
+export function createOpenForgePluginSdkPackageExports(): Record<
+  string,
+  string | { types: string; default: string }
+>
+
+export function createOpenForgePluginSdkTypeScriptPaths(): Record<string, [string]>
+
+export function loadOpenForgePluginSdkTypeScriptPaths(workspaceRoot: string): Promise<Record<string, unknown>>
+export function assertOpenForgePluginSdkEntrypointRegistries(registries: {
+  packageExports: unknown
+  typeScriptPaths: unknown
+}): void

package/dist/publicEntrypoints.mjs

@@ -0,0 +1,104 @@
+import { readFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { assertRegistryMatchesCanonicalManifest } from './registryValidation.mjs'
+import { OPENFORGE_PLUGIN_SDK_PUBLIC_UI_EXPORTS } from './publicUiExports.mjs'
+
+const PLUGIN_SDK_PACKAGE_NAME = '@openforge-app/plugin-sdk'
+
+function moduleEntrypoint(packageSubpath, sourceName) {
+  const importSuffix = packageSubpath === '.' ? '' : packageSubpath.slice(1)
+  return Object.freeze({
+    packageSubpath,
+    importSpecifier: `${PLUGIN_SDK_PACKAGE_NAME}${importSuffix}`,
+    sourcePath: `src/${sourceName}.ts`,
+    workspaceSourcePath: `packages/plugin-sdk/src/${sourceName}.ts`,
+    packageExport: Object.freeze({
+      types: `./dist/${sourceName}.d.ts`,
+      default: `./dist/${sourceName}.js`,
+    }),
+  })
+}
+
+const PUBLIC_MODULE_ENTRYPOINTS = [
+  moduleEntrypoint('.', 'index'),
+  moduleEntrypoint('./frontend', 'frontend'),
+  moduleEntrypoint('./backend', 'backend'),
+  moduleEntrypoint('./testing', 'testing'),
+  moduleEntrypoint('./vite', 'vite'),
+  moduleEntrypoint('./domain', 'domain'),
+  moduleEntrypoint('./prStatusPresentation', 'prStatusPresentation'),
+  moduleEntrypoint('./markdown', 'markdown'),
+  moduleEntrypoint('./numberParsing', 'numberParsing'),
+  moduleEntrypoint('./projectFileTree', 'projectFileTree'),
+  moduleEntrypoint('./sanitize', 'sanitize'),
+  moduleEntrypoint('./pluginIcons', 'pluginIcons'),
+  moduleEntrypoint('./fileIcons', 'fileIcons'),
+  moduleEntrypoint('./collapsibleSectionState', 'collapsibleSectionState'),
+  moduleEntrypoint('./taskBrowserDevToolsShortcuts', 'taskBrowserDevToolsShortcuts'),
+]
+
+const PACKAGE_METADATA_SCHEMA_ENTRYPOINT = Object.freeze({
+  packageSubpath: './package-metadata-schema.json',
+  importSpecifier: `${PLUGIN_SDK_PACKAGE_NAME}/package-metadata-schema.json`,
+  sourcePath: 'src/openforgePackageMetadataSchema.json',
+  workspaceSourcePath: 'packages/plugin-sdk/src/openforgePackageMetadataSchema.json',
+  packageExport: './dist/openforgePackageMetadataSchema.json',
+})
+
+const PUBLIC_UI_ENTRYPOINTS = OPENFORGE_PLUGIN_SDK_PUBLIC_UI_EXPORTS.map((entrypoint) => Object.freeze({
+  packageSubpath: entrypoint.packageSubpath,
+  importSpecifier: entrypoint.importSpecifier,
+  sourcePath: entrypoint.sourcePath,
+  workspaceSourcePath: entrypoint.workspaceSourcePath,
+  packageExport: entrypoint.distPath,
+}))
+
+/** Canonical registrations for every public Plugin SDK entrypoint. */
+export const OPENFORGE_PLUGIN_SDK_PUBLIC_ENTRYPOINTS = Object.freeze([
+  ...PUBLIC_MODULE_ENTRYPOINTS.slice(0, 5),
+  PACKAGE_METADATA_SCHEMA_ENTRYPOINT,
+  ...PUBLIC_MODULE_ENTRYPOINTS.slice(5),
+  ...PUBLIC_UI_ENTRYPOINTS,
+])
+
+export function createOpenForgePluginSdkPackageExports() {
+  return Object.fromEntries(
+    OPENFORGE_PLUGIN_SDK_PUBLIC_ENTRYPOINTS.map(({ packageSubpath, packageExport }) => [
+      packageSubpath,
+      typeof packageExport === 'string' ? packageExport : { ...packageExport },
+    ]),
+  )
+}
+
+export function createOpenForgePluginSdkTypeScriptPaths() {
+  return Object.fromEntries(
+    OPENFORGE_PLUGIN_SDK_PUBLIC_ENTRYPOINTS.map(({ importSpecifier, workspaceSourcePath }) => [
+      importSpecifier,
+      [`./${workspaceSourcePath}`],
+    ]),
+  )
+}
+
+export async function loadOpenForgePluginSdkTypeScriptPaths(workspaceRoot) {
+  const typeScriptConfig = JSON.parse(
+    (await readFile(resolve(workspaceRoot, 'tsconfig.json'), 'utf8')).replace(/\/\*[\s\S]*?\*\//g, ''),
+  )
+
+  return Object.fromEntries(
+    Object.entries(typeScriptConfig.compilerOptions.paths)
+      .filter(([specifier]) => specifier === PLUGIN_SDK_PACKAGE_NAME || specifier.startsWith(`${PLUGIN_SDK_PACKAGE_NAME}/`)),
+  )
+}
+
+export function assertOpenForgePluginSdkEntrypointRegistries({ packageExports, typeScriptPaths }) {
+  assertRegistryMatchesCanonicalManifest({
+    registryName: 'Plugin SDK package exports',
+    actual: packageExports,
+    expected: createOpenForgePluginSdkPackageExports(),
+  })
+  assertRegistryMatchesCanonicalManifest({
+    registryName: 'Plugin SDK root TypeScript paths',
+    actual: typeScriptPaths,
+    expected: createOpenForgePluginSdkTypeScriptPaths(),
+  })
+}

package/dist/publicUiExports.mjs

@@ -1,3 +1,5 @@
+import { assertRegistryMatchesCanonicalManifest } from './registryValidation.mjs'
+
 const PLUGIN_SDK_PACKAGE_NAME = '@openforge-app/plugin-sdk'
 
 const PUBLIC_UI_COMPONENT_NAMES = Object.freeze([
@@ -7,9 +9,11 @@ const PUBLIC_UI_COMPONENT_NAMES = Object.freeze([
   'ResizablePanel',
   'Modal',
   'PluginPageHeader',
+  'PluginPageShell',
   'PluginViewState',
   'PluginSidebarLink',
   'FileTypeIcon',
+  'ProjectFileTree',
   'CollapsibleSection',
 ])
 
@@ -36,26 +40,12 @@ export function createOpenForgePluginSdkPublicUiPackageExports() {
 }
 
 export function assertOpenForgePluginSdkPublicUiPackageExports(packageExports) {
-  if (!packageExports || typeof packageExports !== 'object' || Array.isArray(packageExports)) {
-    throw new Error('Plugin SDK package.json must define an exports object')
-  }
-
-  const expected = createOpenForgePluginSdkPublicUiPackageExports()
-  const actual = Object.fromEntries(
-    Object.entries(packageExports).filter(([subpath]) => subpath.startsWith('./ui/')),
-  )
-  const expectedEntries = Object.entries(expected)
-  const missingOrMismatched = expectedEntries
-    .filter(([subpath, distPath]) => actual[subpath] !== distPath)
-    .map(([subpath, distPath]) => `${subpath} -> ${distPath}`)
-  const unexpected = Object.keys(actual).filter((subpath) => !(subpath in expected))
-
-  if (missingOrMismatched.length === 0 && unexpected.length === 0) return
-
-  const details = [
-    missingOrMismatched.length > 0 ? `missing or mismatched: ${missingOrMismatched.join(', ')}` : null,
-    unexpected.length > 0 ? `not in the canonical manifest: ${unexpected.join(', ')}` : null,
-  ].filter(Boolean)
-
-  throw new Error(`Plugin SDK public UI exports drifted from the canonical manifest (${details.join('; ')})`)
+  assertRegistryMatchesCanonicalManifest({
+    registryName: 'Plugin SDK public UI exports',
+    actual: packageExports,
+    expected: createOpenForgePluginSdkPublicUiPackageExports(),
+    invalidRegistryMessage: 'Plugin SDK package.json must define an exports object',
+    includeActualEntry: ([subpath]) => subpath.startsWith('./ui/'),
+    formatMissingOrMismatched: ([subpath, distPath]) => `${subpath} -> ${distPath}`,
+  })
 }

package/dist/registryValidation.d.mts

@@ -0,0 +1,11 @@
+type Registry = Record<string, unknown>
+type RegistryEntry = [string, unknown]
+
+export function assertRegistryMatchesCanonicalManifest(options: {
+  registryName: string
+  actual: unknown
+  expected: Registry
+  invalidRegistryMessage?: string
+  includeActualEntry?: (entry: RegistryEntry) => boolean
+  formatMissingOrMismatched?: (entry: RegistryEntry) => string
+}): void

package/dist/registryValidation.mjs

@@ -0,0 +1,30 @@
+import { isDeepStrictEqual } from 'node:util'
+
+export function assertRegistryMatchesCanonicalManifest({
+  registryName,
+  actual,
+  expected,
+  invalidRegistryMessage = `${registryName} must be an object`,
+  includeActualEntry = () => true,
+  formatMissingOrMismatched = ([key]) => key,
+}) {
+  if (!actual || typeof actual !== 'object' || Array.isArray(actual)) {
+    throw new Error(invalidRegistryMessage)
+  }
+
+  const comparableActual = Object.fromEntries(Object.entries(actual).filter(includeActualEntry))
+
+  const missingOrMismatched = Object.entries(expected)
+    .filter(([key, value]) => !isDeepStrictEqual(comparableActual[key], value))
+    .map(formatMissingOrMismatched)
+  const unexpected = Object.keys(comparableActual).filter((key) => !(key in expected))
+
+  if (missingOrMismatched.length === 0 && unexpected.length === 0) return
+
+  const details = [
+    missingOrMismatched.length > 0 ? `missing or mismatched: ${missingOrMismatched.join(', ')}` : null,
+    unexpected.length > 0 ? `not in the canonical manifest: ${unexpected.join(', ')}` : null,
+  ].filter(Boolean)
+
+  throw new Error(`${registryName} drifted from the canonical manifest (${details.join('; ')})`)
+}

package/dist/sanitize.d.ts

@@ -4,3 +4,5 @@
  * Allows safe structural/formatting HTML through.
  */
 export declare function sanitizeHtml(dirty: string): string;
+/** Sanitize generated Mermaid SVG before it is inserted into the document. */
+export declare function sanitizeMermaidSvg(dirty: string): string;

package/dist/sanitize.js

@@ -11,3 +11,134 @@ export function sanitizeHtml(dirty) {
         FORBID_ATTR: ['style'],
     });
 }
+const SAFE_MERMAID_STYLE_PROPERTIES = new Set([
+    'color',
+    'dominant-baseline',
+    'fill',
+    'fill-opacity',
+    'font-family',
+    'font-size',
+    'font-style',
+    'font-weight',
+    'max-width',
+    'opacity',
+    'stroke',
+    'stroke-dasharray',
+    'stroke-dashoffset',
+    'stroke-linecap',
+    'stroke-linejoin',
+    'stroke-opacity',
+    'stroke-width',
+    'text-align',
+    'text-anchor',
+    'white-space',
+]);
+function getSafeMermaidStyleDeclarations(style) {
+    const safeDeclarations = [];
+    for (const property of Array.from(style)) {
+        if (!SAFE_MERMAID_STYLE_PROPERTIES.has(property))
+            continue;
+        const value = style.getPropertyValue(property);
+        if (/url\s*\(|expression\s*\(|javascript:|data:|@import|var\s*\(/i.test(value))
+            continue;
+        const priority = style.getPropertyPriority(property);
+        safeDeclarations.push(`${property}: ${value}${priority ? ` !${priority}` : ''}`);
+    }
+    return safeDeclarations;
+}
+function removeCssAtRules(css) {
+    let result = '';
+    let index = 0;
+    while (index < css.length) {
+        if (css[index] !== '@') {
+            result += css[index++];
+            continue;
+        }
+        let depth = 0;
+        let quote = '';
+        for (; index < css.length; index++) {
+            const character = css[index];
+            if (quote) {
+                if (character === '\\')
+                    index++;
+                else if (character === quote)
+                    quote = '';
+                continue;
+            }
+            if (character === '"' || character === "'") {
+                quote = character;
+            }
+            else if (character === '{') {
+                depth++;
+            }
+            else if (character === '}') {
+                if (--depth <= 0) {
+                    index++;
+                    break;
+                }
+            }
+            else if (character === ';' && depth === 0) {
+                index++;
+                break;
+            }
+        }
+    }
+    return result;
+}
+function sanitizeMermaidStylesheet(css, styleParser) {
+    const withoutComments = css.replace(/\/\*[\s\S]*?\*\//g, '');
+    const safeRuleSource = removeCssAtRules(withoutComments);
+    const rules = [];
+    const rulePattern = /([^{}]+)\{([^{}]*)\}/g;
+    let consumedUntil = 0;
+    let match;
+    while ((match = rulePattern.exec(safeRuleSource)) !== null) {
+        if (safeRuleSource.slice(consumedUntil, match.index).trim())
+            return '';
+        consumedUntil = rulePattern.lastIndex;
+        const selector = match[1].trim();
+        if (!selector || /[{}@\\]/.test(selector))
+            continue;
+        styleParser.setAttribute('style', match[2]);
+        const declarations = getSafeMermaidStyleDeclarations(styleParser.style);
+        if (declarations.length > 0)
+            rules.push(`${selector} { ${declarations.join('; ')} }`);
+    }
+    if (safeRuleSource.slice(consumedUntil).trim())
+        return '';
+    return rules.join('\n');
+}
+function sanitizeMermaidStyles(svg) {
+    const template = document.createElement('template');
+    template.innerHTML = svg;
+    const styleParser = document.createElement('span');
+    for (const element of template.content.querySelectorAll('[style]')) {
+        styleParser.setAttribute('style', element.getAttribute('style') ?? '');
+        const safeDeclarations = getSafeMermaidStyleDeclarations(styleParser.style);
+        if (safeDeclarations.length > 0) {
+            element.setAttribute('style', safeDeclarations.join('; '));
+        }
+        else {
+            element.removeAttribute('style');
+        }
+    }
+    for (const style of template.content.querySelectorAll('style')) {
+        const sanitized = sanitizeMermaidStylesheet(style.textContent ?? '', styleParser);
+        if (sanitized) {
+            style.textContent = sanitized;
+        }
+        else {
+            style.remove();
+        }
+    }
+    return template.innerHTML;
+}
+/** Sanitize generated Mermaid SVG before it is inserted into the document. */
+export function sanitizeMermaidSvg(dirty) {
+    const sanitized = DOMPurify.sanitize(dirty, {
+        USE_PROFILES: { svg: true, svgFilters: true },
+        FORBID_TAGS: ['script', 'foreignObject', 'iframe', 'object', 'embed', 'image', 'a'],
+        FORBID_ATTR: ['href', 'xlink:href', 'target'],
+    });
+    return sanitizeMermaidStyles(sanitized);
+}

package/dist/taskBrowserDevToolsShortcuts.d.ts

@@ -0,0 +1,12 @@
+export type TaskBrowserDevToolsShortcutPlatform = 'macos' | 'other';
+export type TaskBrowserDevToolsShortcut = 'toggle' | 'elements' | 'console';
+export interface TaskBrowserDevToolsShortcutInput {
+    key: string;
+    keyDown: boolean;
+    repeat: boolean;
+    control: boolean;
+    shift: boolean;
+    alt: boolean;
+    meta: boolean;
+}
+export declare function classifyTaskBrowserDevToolsShortcut(platform: TaskBrowserDevToolsShortcutPlatform, input: TaskBrowserDevToolsShortcutInput): TaskBrowserDevToolsShortcut | null;

package/dist/taskBrowserDevToolsShortcuts.js

@@ -0,0 +1,20 @@
+export function classifyTaskBrowserDevToolsShortcut(platform, input) {
+    if (!input.keyDown || input.repeat)
+        return null;
+    if (input.key === 'f12')
+        return 'toggle';
+    if (input.key === 'c') {
+        const elementsModified = platform === 'macos'
+            ? input.meta && input.shift && !input.control && !input.alt
+            : input.control && input.shift && !input.meta && !input.alt;
+        return elementsModified ? 'elements' : null;
+    }
+    const modified = platform === 'macos'
+        ? input.meta && input.alt && !input.control && !input.shift
+        : input.control && input.shift && !input.meta && !input.alt;
+    if (!modified)
+        return null;
+    if (input.key === 'i')
+        return 'toggle';
+    return input.key === 'j' ? 'console' : null;
+}