feedtack 1.1.0 → 1.3.0

package/dist/index.js

@@ -8,8 +8,14 @@ import {
   getPinCoords,
   getTargetMeta,
   getViewportMeta,
-  themeToCSS
-} from "./chunk-3INDOI4N.js";
+  hashField,
+  isContentAdapter,
+  isContentEditAdapter,
+  scanFields,
+  themeToCSS,
+  warnIfNotContentAdapter,
+  warnIfNotContentEditAdapter
+} from "./chunk-GD2SY64K.js";
 
 // src/adapters/ConsoleAdapter.ts
 var ConsoleAdapter = class {
@@ -31,85 +37,6 @@ var ConsoleAdapter = class {
   }
 };
 
-// src/adapters/DiskAdapter.ts
-import { readdir, readFile, writeFile, mkdir } from "fs/promises";
-import { join } from "path";
-var DiskAdapter = class {
-  constructor(config = {}) {
-    this.dir = config.directory ?? ".feedback";
-  }
-  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;
-    });
-  }
-  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)
-    );
-  }
-};
-
 // src/adapters/LocalStorageAdapter.ts
 var LocalStorageAdapter = class {
   constructor(config = {}) {
@@ -213,10 +140,40 @@ 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,
-  DiskAdapter,
   FeedtackEngine,
   LocalStorageAdapter,
   SCHEMA_VERSION,
@@ -228,5 +185,11 @@ export {
   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 { F as FeedtackAdapter, t as FeedtackUser, s as FeedtackTheme, e as FeedbackItem, o as FeedtackFlushEvent } from '../types-Cu4Oahg4.js';
+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';
 
 /** 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;
@@ -48,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, 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 };