@dryui/feedback 0.0.2

package/dist/utils/svelte-detection.js

@@ -0,0 +1,86 @@
+import { collectRawSvelteLocations } from './svelte-meta.js';
+const INTERNAL_FILE_PATTERNS = [
+    /(^|\/)node_modules\//i,
+    /(^|\/)\.svelte-kit\//i,
+    /(^|\/)svelte\/internal\//i,
+    /(^|\/)svelte\/src\/internal\//i,
+    /(^|\/)vite\/deps\//i,
+    /^webpack-internal:/i,
+    /^<anonymous>$/i,
+];
+function normalizeSourceFile(file) {
+    const normalized = file.trim().replace(/^file:\/\//i, '').replace(/\\/g, '/');
+    if (!normalized)
+        return null;
+    for (const pattern of INTERNAL_FILE_PATTERNS) {
+        if (pattern.test(normalized))
+            return null;
+    }
+    const srcIndex = normalized.lastIndexOf('/src/');
+    if (srcIndex >= 0) {
+        return normalized.slice(srcIndex + 1);
+    }
+    const routesIndex = normalized.lastIndexOf('/routes/');
+    if (routesIndex >= 0) {
+        return normalized.slice(routesIndex + 1);
+    }
+    const libIndex = normalized.lastIndexOf('/lib/');
+    if (libIndex >= 0) {
+        return normalized.slice(libIndex + 1);
+    }
+    return normalized;
+}
+function getComponentName(file) {
+    const normalized = file.replace(/\\/g, '/');
+    const parts = normalized.split('/').filter(Boolean);
+    const filePart = parts.at(-1) ?? normalized;
+    const baseName = filePart.replace(/\.svelte(?:\.(?:js|ts))?$/i, '');
+    const rawName = baseName === 'index' ? (parts.at(-2) ?? baseName) : baseName;
+    if (rawName.startsWith('+') || rawName.includes('[')) {
+        return rawName;
+    }
+    const normalizedName = rawName
+        .split(/[-_]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+    if (normalizedName) {
+        return normalizedName;
+    }
+    return rawName.charAt(0).toUpperCase() + rawName.slice(1);
+}
+function formatSourceFile(file, line) {
+    return line ? `${file}:${line}` : file;
+}
+function collectComponentChain(target) {
+    return collectRawSvelteLocations(target)
+        .map((location) => {
+        const file = normalizeSourceFile(location.file);
+        if (!file)
+            return null;
+        return { file, ...(location.line ? { line: location.line } : {}) };
+    })
+        .filter((location) => location !== null);
+}
+export function detectSvelteMetadata(target) {
+    const chain = collectComponentChain(target);
+    if (chain.length === 0) {
+        return {
+            componentStack: [],
+            sourceFiles: [],
+        };
+    }
+    const nearest = chain[0];
+    const outerToInner = [...chain].reverse();
+    const componentStack = outerToInner.map((entry) => getComponentName(entry.file));
+    const sourceFiles = outerToInner.map((entry) => entry.file);
+    return {
+        sourceFile: formatSourceFile(nearest.file, nearest.line),
+        svelteComponent: componentStack.join(' > '),
+        componentStack,
+        sourceFiles,
+    };
+}
+export function hasSvelteMetadata(target) {
+    return detectSvelteMetadata(target).componentStack.length > 0;
+}

package/dist/utils/svelte-meta.d.ts

@@ -0,0 +1,6 @@
+export interface RawSvelteLocation {
+    readonly file: string;
+    readonly line?: number;
+}
+export declare function collectRawSvelteLocations(target: EventTarget | null): RawSvelteLocation[];
+export declare function findTargetElement(target: EventTarget | null): Element | null;

package/dist/utils/svelte-meta.js

@@ -0,0 +1,69 @@
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isNodeLike(value) {
+    return typeof Node !== 'undefined' && value instanceof Node;
+}
+function getNumericLine(value) {
+    if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+        return Math.trunc(value);
+    }
+    return undefined;
+}
+function readRawSvelteLocation(node) {
+    const meta = node.__svelte_meta;
+    if (!isRecord(meta))
+        return null;
+    const loc = isRecord(meta.loc) ? meta.loc : null;
+    if (!loc || typeof loc.file !== 'string')
+        return null;
+    const start = isRecord(loc.start) ? loc.start : null;
+    const line = getNumericLine(loc.line) ?? getNumericLine(start?.line);
+    return { file: loc.file, ...(line ? { line } : {}) };
+}
+function getNextNode(node) {
+    if (typeof ShadowRoot !== 'undefined' && node instanceof ShadowRoot) {
+        return node.host;
+    }
+    if (node.parentNode) {
+        return node.parentNode;
+    }
+    const root = typeof node.getRootNode === 'function' ? node.getRootNode() : null;
+    if (typeof ShadowRoot !== 'undefined' && root instanceof ShadowRoot) {
+        return root.host;
+    }
+    return null;
+}
+export function collectRawSvelteLocations(target) {
+    if (!isNodeLike(target))
+        return [];
+    const chain = [];
+    const visited = new Set();
+    let current = target;
+    while (current && !visited.has(current)) {
+        visited.add(current);
+        const location = readRawSvelteLocation(current);
+        if (location) {
+            const previous = chain.at(-1);
+            if (previous?.file === location.file) {
+                if (previous.line === undefined && location.line !== undefined) {
+                    chain[chain.length - 1] = location;
+                }
+            }
+            else {
+                chain.push(location);
+            }
+        }
+        current = getNextNode(current);
+    }
+    return chain;
+}
+export function findTargetElement(target) {
+    if (target instanceof Element)
+        return target;
+    if (target instanceof Text)
+        return target.parentElement;
+    if (isNodeLike(target) && target.parentNode instanceof Element)
+        return target.parentNode;
+    return null;
+}

package/dist/utils/sync.d.ts

@@ -0,0 +1,18 @@
+import type { Annotation, Session, SessionWithAnnotations, ThreadMessage } from '../types.js';
+export interface ActionResponse {
+    success: boolean;
+    annotationCount: number;
+    delivered: {
+        sseListeners: number;
+        webhooks: number;
+        total: number;
+    };
+}
+export declare function listSessions(endpoint: string): Promise<Session[]>;
+export declare function createSession(endpoint: string, url: string): Promise<Session>;
+export declare function getSession(endpoint: string, sessionId: string): Promise<SessionWithAnnotations>;
+export declare function syncAnnotation(endpoint: string, sessionId: string, annotation: Annotation): Promise<Annotation>;
+export declare function updateAnnotation(endpoint: string, annotationId: string, data: Partial<Annotation>): Promise<Annotation>;
+export declare function replyToAnnotation(endpoint: string, annotationId: string, message: ThreadMessage): Promise<Annotation>;
+export declare function deleteAnnotation(endpoint: string, annotationId: string): Promise<void>;
+export declare function requestAction(endpoint: string, sessionId: string, output: string): Promise<ActionResponse>;

package/dist/utils/sync.js

@@ -0,0 +1,62 @@
+async function readJson(response, message) {
+    if (!response.ok) {
+        throw new Error(`${message}: ${response.status}`);
+    }
+    return response.json();
+}
+export async function listSessions(endpoint) {
+    const response = await fetch(`${endpoint}/sessions`);
+    return readJson(response, 'Failed to list sessions');
+}
+export async function createSession(endpoint, url) {
+    const response = await fetch(`${endpoint}/sessions`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ url }),
+    });
+    return readJson(response, 'Failed to create session');
+}
+export async function getSession(endpoint, sessionId) {
+    const response = await fetch(`${endpoint}/sessions/${sessionId}`);
+    return readJson(response, 'Failed to get session');
+}
+export async function syncAnnotation(endpoint, sessionId, annotation) {
+    const response = await fetch(`${endpoint}/sessions/${sessionId}/annotations`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(annotation),
+    });
+    return readJson(response, 'Failed to sync annotation');
+}
+export async function updateAnnotation(endpoint, annotationId, data) {
+    const response = await fetch(`${endpoint}/annotations/${annotationId}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(data),
+    });
+    return readJson(response, 'Failed to update annotation');
+}
+export async function replyToAnnotation(endpoint, annotationId, message) {
+    const response = await fetch(`${endpoint}/annotations/${annotationId}/thread`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(message),
+    });
+    return readJson(response, 'Failed to reply to annotation');
+}
+export async function deleteAnnotation(endpoint, annotationId) {
+    const response = await fetch(`${endpoint}/annotations/${annotationId}`, {
+        method: 'DELETE',
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to delete annotation: ${response.status}`);
+    }
+}
+export async function requestAction(endpoint, sessionId, output) {
+    const response = await fetch(`${endpoint}/sessions/${sessionId}/action`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ output }),
+    });
+    return readJson(response, 'Failed to request action');
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@dryui/feedback",
+  "version": "0.0.2",
+  "author": "Rob Balfre",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rob-balfre/dryui.git",
+    "directory": "packages/feedback"
+  },
+  "homepage": "https://github.com/rob-balfre/dryui#readme",
+  "bugs": {
+    "url": "https://github.com/rob-balfre/dryui/issues"
+  },
+  "type": "module",
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.js",
+      "svelte": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "svelte": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "svelte": "./dist/index.js",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "generate-layout-library": "node ./scripts/generate-layout-library.mjs",
+    "build": "bun run generate-layout-library && svelte-package -i src",
+    "check": "svelte-check --tsconfig ./tsconfig.json"
+  },
+  "dependencies": {
+    "@dryui/primitives": "workspace:*",
+    "@dryui/ui": "workspace:*",
+    "@dryui/mcp": "workspace:*"
+  },
+  "peerDependencies": {
+    "svelte": "^5.55.1",
+    "lucide-svelte": ">=1.0.1"
+  },
+  "peerDependenciesMeta": {
+    "lucide-svelte": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "svelte": "^5.55.1",
+    "@sveltejs/package": "^2.5.7",
+    "svelte-check": "^4.4.5",
+    "typescript": "^6.0.2"
+  }
+}