feedtack 1.0.1 → 1.2.0

package/dist/index.d.ts

@@ -1,5 +1,7 @@
-import { F as FeedtackAdapter, a as FeedtackPayload, b as FeedtackReply, c as FeedtackResolution, d as FeedtackFilter, e as FeedbackItem, f as FeedtackDeviceMeta, g as FeedtackPageMeta, h as FeedtackViewportMeta, i as FeedtackPinTarget } from './theme-BdqpMipn.js';
-export { A as AncestorNode, j as FeedtackArchive, k as FeedtackBoundingRect, l as FeedtackPin, m as FeedtackScope, n as FeedtackSentiment, o as FeedtackTheme, p as FeedtackUser, S as SCHEMA_VERSION, t as themeToCSS } from './theme-BdqpMipn.js';
+import { F as FeedtackAdapter, a as FeedtackPayload, b as FeedtackReply, c as FeedtackResolution, d as FeedtackFilter, e as FeedbackItem, C as ContentAdapter, f as ContentEditAdapter, g as FieldFilter, h as FieldApprovalState, i as FieldApproval, j as FeedtackDeviceMeta, k as FeedtackPageMeta, l as FeedtackViewportMeta, m as FeedtackPinTarget } from './adapter-Cn59URIG.js';
+export { A as AncestorNode, n as FeedtackArchive, o as FeedtackBoundingRect, p as FeedtackPin, q as FeedtackScope, r as FeedtackSentiment, s as FeedtackUser, t as FieldChange, u as FocusedFieldInfo, S as SCHEMA_VERSION, v as isContentAdapter, w as isContentEditAdapter, x as warnIfNotContentAdapter, y as warnIfNotContentEditAdapter } from './adapter-Cn59URIG.js';
+import { F as FeedtackEngineOpts, a as FeedtackEngineState, b as FeedtackStateListener } from './types-CHrWe7xT.js';
+export { c as FeedtackFlushEvent, d as FeedtackTheme, g as generateId, t as themeToCSS } from './types-CHrWe7xT.js';
 
 /** Development adapter — logs all operations to the browser console */
 declare class ConsoleAdapter implements FeedtackAdapter {
@@ -34,9 +36,13 @@ interface WebhookAdapterConfig {
     updateUrl?: string;
     /** Required: async function that returns persisted feedback items */
     loadFeedback: (filter?: FeedtackFilter) => Promise<FeedbackItem[]>;
+    /** Optional: async function that returns stored field approvals */
+    loadApprovals?: (filter?: FieldFilter) => Promise<FieldApprovalState[]>;
+    /** Optional: async function that returns all stored field values for hydration */
+    loadFields?: () => Promise<Record<string, string>>;
 }
 /** Production adapter — POSTs feedback as JSON to a webhook endpoint */
-declare class WebhookAdapter implements FeedtackAdapter {
+declare class WebhookAdapter implements FeedtackAdapter, ContentAdapter, ContentEditAdapter {
     private config;
     constructor(config: WebhookAdapterConfig);
     private post;
@@ -45,8 +51,28 @@ declare class WebhookAdapter implements FeedtackAdapter {
     resolve(feedbackId: string, resolution: Omit<FeedtackResolution, 'feedbackId'>): Promise<void>;
     archive(feedbackId: string, userId: string): Promise<void>;
     loadFeedback(filter?: FeedtackFilter): Promise<FeedbackItem[]>;
+    approve(fieldPath: string, approval: FieldApproval): Promise<void>;
+    revokeApproval(fieldPath: string, userId: string): Promise<void>;
+    loadApprovals(filter?: FieldFilter): Promise<FieldApprovalState[]>;
+    loadFields(): Promise<Record<string, string>>;
+    saveField(fieldPath: string, value: string): Promise<void>;
 }
 
+interface ScannedField {
+    fieldPath: string;
+    element: Element;
+    content: string;
+}
+/**
+ * Scans the DOM for elements annotated with data-feedtack-field.
+ * @param root - Element to search within. Defaults to document.body.
+ */
+declare function scanFields(root?: Element): ScannedField[];
+/**
+ * Computes a 12-character truncated SHA-256 hash of a string using Web Crypto API.
+ */
+declare function hashField(content: string): Promise<string>;
+
 declare function getViewportMeta(): FeedtackViewportMeta;
 declare function getPageMeta(): FeedtackPageMeta;
 declare function getDeviceMeta(): FeedtackDeviceMeta;
@@ -65,4 +91,49 @@ declare function getCSSSelector(element: Element): string;
 /** Capture DOM target metadata at the clicked element */
 declare function getTargetMeta(element: Element): FeedtackPinTarget;
 
-export { ConsoleAdapter, FeedbackItem, FeedtackAdapter, FeedtackDeviceMeta, FeedtackFilter, FeedtackPageMeta, FeedtackPayload, FeedtackPinTarget, FeedtackReply, FeedtackResolution, FeedtackViewportMeta, LocalStorageAdapter, type LocalStorageAdapterConfig, WebhookAdapter, type WebhookAdapterConfig, getCSSSelector, getDeviceMeta, getPageMeta, getPinCoords, getTargetMeta, getViewportMeta };
+interface FlushController {
+    flushPath: (path: string) => void;
+    clearFlushed: (path: string) => void;
+    detach: () => void;
+}
+
+declare class FeedtackEngine {
+    private readonly opts;
+    private state;
+    private listeners;
+    private actionCtx;
+    private styleEl;
+    private rootEl;
+    private spaNav;
+    flushCtrl: FlushController | null;
+    private inputHandles;
+    constructor(opts: FeedtackEngineOpts);
+    getState(): Readonly<FeedtackEngineState>;
+    subscribe(listener: FeedtackStateListener): () => void;
+    private setState;
+    mount(): void;
+    destroy(): void;
+    private onNavUpdate;
+    activatePinMode(): void;
+    deactivatePinMode(): void;
+    setComment(v: string): void;
+    setSentiment(v: FeedtackEngineState['sentiment']): void;
+    setCommentError(v: boolean): void;
+    setSelectedColor(c: string): void;
+    setOpenThreadId(id: string | null): void;
+    setReplyBody(v: string): void;
+    setComposeScope(s: 'site' | 'page'): void;
+    openModal(): void;
+    closeModal(): void;
+    getCurrentScope(): "site" | "page" | "element";
+    isArchivedForUser(item: FeedbackItem): boolean;
+    hasUnread(item: FeedbackItem): boolean;
+    hasValidPins(item: FeedbackItem): boolean;
+    handleSubmit(): Promise<void>;
+    handleModalSubmit(): Promise<void>;
+    handleReply(id: string): Promise<void>;
+    handleResolve(id: string): Promise<void>;
+    handleArchive(id: string): Promise<void>;
+}
+
+export { ConsoleAdapter, ContentAdapter, ContentEditAdapter, FeedbackItem, FeedtackAdapter, FeedtackDeviceMeta, FeedtackEngine, FeedtackEngineOpts, FeedtackEngineState, FeedtackFilter, FeedtackPageMeta, FeedtackPayload, FeedtackPinTarget, FeedtackReply, FeedtackResolution, FeedtackStateListener, FeedtackViewportMeta, FieldApproval, FieldApprovalState, FieldFilter, LocalStorageAdapter, type LocalStorageAdapterConfig, WebhookAdapter, type WebhookAdapterConfig, getCSSSelector, getDeviceMeta, getPageMeta, getPinCoords, getTargetMeta, getViewportMeta, hashField, scanFields };

package/dist/index.js

@@ -1,13 +1,21 @@
 import {
+  FeedtackEngine,
   SCHEMA_VERSION,
+  generateId,
   getCSSSelector,
   getDeviceMeta,
   getPageMeta,
   getPinCoords,
   getTargetMeta,
   getViewportMeta,
-  themeToCSS
-} from "./chunk-2A5LLDLP.js";
+  hashField,
+  isContentAdapter,
+  isContentEditAdapter,
+  scanFields,
+  themeToCSS,
+  warnIfNotContentAdapter,
+  warnIfNotContentEditAdapter
+} from "./chunk-GD2SY64K.js";
 
 // src/adapters/ConsoleAdapter.ts
 var ConsoleAdapter = class {
@@ -132,17 +140,56 @@ var WebhookAdapter = class {
   async loadFeedback(filter) {
     return this.config.loadFeedback(filter);
   }
+  // ContentAdapter implementation
+  async approve(fieldPath, approval) {
+    const url = this.config.updateUrl ?? this.config.submitUrl;
+    await this.post(url, { type: "approve", fieldPath, ...approval });
+  }
+  async revokeApproval(fieldPath, userId) {
+    const url = this.config.updateUrl ?? this.config.submitUrl;
+    await this.post(url, { type: "revoke", fieldPath, userId });
+  }
+  async loadApprovals(filter) {
+    if (this.config.loadApprovals) {
+      return this.config.loadApprovals(filter);
+    }
+    return [];
+  }
+  // ContentEditAdapter implementation
+  async loadFields() {
+    if (this.config.loadFields) {
+      return this.config.loadFields();
+    }
+    return {};
+  }
+  async saveField(fieldPath, value) {
+    const url = this.config.updateUrl ?? this.config.submitUrl;
+    await this.post(url, {
+      type: "save-field",
+      fieldPath,
+      value,
+      clearApproval: true
+    });
+  }
 };
 export {
   ConsoleAdapter,
+  FeedtackEngine,
   LocalStorageAdapter,
   SCHEMA_VERSION,
   WebhookAdapter,
+  generateId,
   getCSSSelector,
   getDeviceMeta,
   getPageMeta,
   getPinCoords,
   getTargetMeta,
   getViewportMeta,
-  themeToCSS
+  hashField,
+  isContentAdapter,
+  isContentEditAdapter,
+  scanFields,
+  themeToCSS,
+  warnIfNotContentAdapter,
+  warnIfNotContentEditAdapter
 };

package/dist/node/index.d.ts

@@ -0,0 +1,27 @@
+import { F as FeedtackAdapter, C as ContentAdapter, f as ContentEditAdapter, a as FeedtackPayload, b as FeedtackReply, c as FeedtackResolution, d as FeedtackFilter, e as FeedbackItem, i as FieldApproval, g as FieldFilter, h as FieldApprovalState } from '../adapter-Cn59URIG.js';
+
+interface DiskAdapterConfig {
+    /** Directory to store JSON files in. Default: '.feedback' */
+    directory?: string;
+}
+/** Node.js adapter — persists each feedback item as a JSON file on disk */
+declare class DiskAdapter implements FeedtackAdapter, ContentAdapter, ContentEditAdapter {
+    private dir;
+    private approvalsDir;
+    private fieldsDir;
+    constructor(config?: DiskAdapterConfig);
+    submit(payload: FeedtackPayload): Promise<void>;
+    reply(feedbackId: string, reply: Omit<FeedtackReply, 'id' | 'feedbackId'>): Promise<void>;
+    resolve(feedbackId: string, resolution: Omit<FeedtackResolution, 'feedbackId'>): Promise<void>;
+    archive(feedbackId: string, userId: string): Promise<void>;
+    loadFeedback(filter?: FeedtackFilter): Promise<FeedbackItem[]>;
+    approve(fieldPath: string, approval: FieldApproval): Promise<void>;
+    revokeApproval(fieldPath: string, userId: string): Promise<void>;
+    loadApprovals(filter?: FieldFilter): Promise<FieldApprovalState[]>;
+    loadFields(): Promise<Record<string, string>>;
+    saveField(fieldPath: string, value: string): Promise<void>;
+    private read;
+    private write;
+}
+
+export { DiskAdapter, type DiskAdapterConfig };

package/dist/node/index.js

@@ -0,0 +1,169 @@
+// src/adapters/DiskAdapter.ts
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+var DiskAdapter = class {
+  constructor(config = {}) {
+    this.dir = config.directory ?? ".feedback";
+    this.approvalsDir = join(this.dir, "approvals");
+    this.fieldsDir = join(this.dir, "fields");
+  }
+  async submit(payload) {
+    await mkdir(this.dir, { recursive: true });
+    const item = {
+      payload,
+      replies: [],
+      resolutions: [],
+      archives: []
+    };
+    await this.write(payload.id, item);
+  }
+  async reply(feedbackId, reply) {
+    const item = await this.read(feedbackId);
+    item.replies.push({
+      id: `r_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 7)}`,
+      feedbackId,
+      ...reply
+    });
+    await this.write(feedbackId, item);
+  }
+  async resolve(feedbackId, resolution) {
+    const item = await this.read(feedbackId);
+    item.resolutions.push({ feedbackId, ...resolution });
+    await this.write(feedbackId, item);
+  }
+  async archive(feedbackId, userId) {
+    const item = await this.read(feedbackId);
+    item.archives.push({
+      feedbackId,
+      archivedBy: { id: userId, name: "", role: "" },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await this.write(feedbackId, item);
+  }
+  async loadFeedback(filter) {
+    let files;
+    try {
+      await mkdir(this.dir, { recursive: true });
+      files = (await readdir(this.dir)).filter((f) => f.endsWith(".json"));
+    } catch {
+      return [];
+    }
+    const items = await Promise.all(
+      files.map(
+        async (f) => JSON.parse(
+          await readFile(join(this.dir, f), "utf-8")
+        )
+      )
+    );
+    if (!filter) return items;
+    return items.filter((item) => {
+      if (filter.scope && item.payload.scope !== filter.scope) return false;
+      if (filter.pathname && item.payload.page.pathname !== filter.pathname)
+        return false;
+      if (filter.url && item.payload.page.url !== filter.url) return false;
+      if (filter.userId && item.payload.submittedBy.id !== filter.userId)
+        return false;
+      return true;
+    });
+  }
+  // ContentAdapter implementation
+  async approve(fieldPath, approval) {
+    await mkdir(this.approvalsDir, { recursive: true });
+    const safeName = fieldPath.replace(/[^a-zA-Z0-9._-]/g, "_");
+    await writeFile(
+      join(this.approvalsDir, `${safeName}.json`),
+      JSON.stringify(approval, null, 2)
+    );
+  }
+  async revokeApproval(fieldPath, userId) {
+    await mkdir(this.approvalsDir, { recursive: true });
+    const safeName = fieldPath.replace(/[^a-zA-Z0-9._-]/g, "_");
+    const filePath = join(this.approvalsDir, `${safeName}.json`);
+    let approval;
+    try {
+      approval = JSON.parse(await readFile(filePath, "utf-8"));
+    } catch {
+      return;
+    }
+    approval.by = approval.by.filter((id) => id !== userId);
+    if (approval.by.length === 0) {
+      const { unlink } = await import("fs/promises");
+      await unlink(filePath).catch(() => {
+      });
+    } else {
+      await writeFile(filePath, JSON.stringify(approval, null, 2));
+    }
+  }
+  async loadApprovals(filter) {
+    let files;
+    try {
+      await mkdir(this.approvalsDir, { recursive: true });
+      files = (await readdir(this.approvalsDir)).filter(
+        (f) => f.endsWith(".json")
+      );
+    } catch {
+      return [];
+    }
+    const states = await Promise.all(
+      files.map(async (f) => {
+        const fieldPath = f.replace(/\.json$/, "").replace(/_/g, ".");
+        const approval = JSON.parse(
+          await readFile(join(this.approvalsDir, f), "utf-8")
+        );
+        return {
+          fieldPath,
+          approval,
+          stale: false
+        };
+      })
+    );
+    if (!filter) return states;
+    return states.filter((s) => {
+      if (filter.fieldPath && s.fieldPath !== filter.fieldPath) return false;
+      return true;
+    });
+  }
+  // ContentEditAdapter implementation
+  async loadFields() {
+    let files;
+    try {
+      await mkdir(this.fieldsDir, { recursive: true });
+      files = (await readdir(this.fieldsDir)).filter((f) => f.endsWith(".json"));
+    } catch {
+      return {};
+    }
+    const entries = await Promise.all(
+      files.map(async (f) => {
+        const fieldPath = f.replace(/\.json$/, "").replace(/_/g, ".");
+        const value = JSON.parse(
+          await readFile(join(this.fieldsDir, f), "utf-8")
+        );
+        return [fieldPath, value];
+      })
+    );
+    return Object.fromEntries(entries);
+  }
+  async saveField(fieldPath, value) {
+    const safeName = fieldPath.replace(/[^a-zA-Z0-9._-]/g, "_");
+    await mkdir(this.fieldsDir, { recursive: true });
+    await writeFile(
+      join(this.fieldsDir, `${safeName}.json`),
+      JSON.stringify(value, null, 2)
+    );
+    const approvalPath = join(this.approvalsDir, `${safeName}.json`);
+    const { unlink } = await import("fs/promises");
+    await unlink(approvalPath).catch(() => {
+    });
+  }
+  async read(id) {
+    return JSON.parse(
+      await readFile(join(this.dir, `${id}.json`), "utf-8")
+    );
+  }
+  async write(id, item) {
+    await writeFile(join(this.dir, `${id}.json`), JSON.stringify(item, null, 2));
+  }
+};
+export {
+  DiskAdapter
+};

package/dist/react/index.d.ts

@@ -1,11 +1,49 @@
+import { d as FeedtackTheme, c as FeedtackFlushEvent } from '../types-CHrWe7xT.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
+import { h as FieldApprovalState, F as FeedtackAdapter, u as FocusedFieldInfo, t as FieldChange, s as FeedtackUser, e as FeedbackItem } from '../adapter-Cn59URIG.js';
 import React from 'react';
-import { e as FeedbackItem, F as FeedtackAdapter, p as FeedtackUser, o as FeedtackTheme } from '../theme-BdqpMipn.js';
 
 /** Fixed palette of 6 colors for pin markers */
 declare const PIN_PALETTE: readonly ["#ef4444", "#3b82f6", "#22c55e", "#f59e0b", "#a855f7", "#ec4899"];
 type PinColor = (typeof PIN_PALETTE)[number];
 
+interface DeployCheckResult {
+    approved: boolean;
+    pending: string[];
+}
+interface UseContentApprovalOptions {
+    /**
+     * When provided, hash computation uses stored values from this map instead of
+     * reading element.textContent from the DOM. Use when static-build values may
+     * differ from live stored values (e.g. when used alongside useContentEdit).
+     */
+    storedValues?: Map<string, string>;
+}
+interface UseContentApprovalResult {
+    fields: FieldApprovalState[];
+    approve: (fieldPath: string) => Promise<void>;
+    revoke: (fieldPath: string) => Promise<void>;
+    rescan: () => Promise<void>;
+    checkDeploy: () => Promise<DeployCheckResult>;
+}
+/**
+ * Hook for managing content field approvals.
+ * Requires an adapter that implements ContentAdapter.
+ */
+declare function useContentApproval(adapter: FeedtackAdapter, userId: string, options?: UseContentApprovalOptions): UseContentApprovalResult;
+
+interface ContentEditToolbarProps {
+    focusedField: FocusedFieldInfo | null;
+    approvalState: FieldApprovalState | null;
+    changes: FieldChange[];
+    saving: string | null;
+    onApprove: (fieldPath: string) => Promise<void>;
+    onRevoke: (fieldPath: string) => Promise<void>;
+    onRevert: (fieldPath: string) => Promise<void>;
+    onCheckDeploy: () => Promise<DeployCheckResult>;
+}
+declare function ContentEditToolbar({ focusedField, approvalState, changes, saving, onApprove, onRevoke, onRevert, onCheckDeploy, }: ContentEditToolbarProps): react_jsx_runtime.JSX.Element;
+
 interface FeedtackContextValue {
     activatePinMode: () => void;
     deactivatePinMode: () => void;
@@ -18,11 +56,6 @@ interface FeedtackContextValue {
     isModalOpen: boolean;
 }
 
-interface FeedtackFlushEvent {
-    pathname: string;
-    items: FeedbackItem[];
-}
-
 interface FeedtackClasses {
     button?: string;
     form?: string;
@@ -53,10 +86,31 @@ interface FeedtackProviderProps {
     flushIdleMs?: number;
     /** User roles that trigger re-scope on reply (default: any non-'agent' role) */
     rescopeRoles?: string[];
+    /**
+     * Called by the consumer (e.g. on a Deploy button click) to check whether all
+     * content fields have current approvals. Feedtack surfaces the data; the consumer
+     * decides what to do with the result.
+     */
+    onDeployCheck?: () => Promise<{
+        approved: boolean;
+        pending: string[];
+    }>;
 }
 declare function FeedtackProvider({ children, adapter, currentUser, hotkey, adminOnly, theme, classes, sentimentLabels, onError, disabled, renderPinIcon, onFlush, flushIdleMs, rescopeRoles, }: FeedtackProviderProps): react_jsx_runtime.JSX.Element;
 
+interface UseContentEditResult extends UseContentApprovalResult {
+    active: boolean;
+    activate: () => Promise<void>;
+    deactivate: () => void;
+    changes: FieldChange[];
+    revert: (fieldPath: string) => Promise<void>;
+    saving: string | null;
+    focusedField: FocusedFieldInfo | null;
+    toolbarProps: ContentEditToolbarProps;
+}
+declare function useContentEdit(adapter: FeedtackAdapter, userId: string): UseContentEditResult;
+
 /** Hook for host app to programmatically control feedtack */
 declare function useFeedtack(): FeedtackContextValue;
 
-export { type FeedtackClasses, type FeedtackContextValue, type FeedtackFlushEvent, FeedtackProvider, type FeedtackProviderProps, type FeedtackSentimentLabels, PIN_PALETTE, type PinColor, useFeedtack };
+export { ContentEditToolbar, type ContentEditToolbarProps, type DeployCheckResult, type FeedtackClasses, type FeedtackContextValue, FeedtackFlushEvent, FeedtackProvider, type FeedtackProviderProps, type FeedtackSentimentLabels, PIN_PALETTE, type PinColor, type UseContentApprovalOptions, type UseContentApprovalResult, type UseContentEditResult, useContentApproval, useContentEdit, useFeedtack };