feedtack 1.1.0 → 1.2.0

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 };