@juo/blocks 1.0.0

package/dist/juo-workflow-RSrOuKUH.js

@@ -0,0 +1,591 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { c as createContext, d, E, i as getDefinedBlocks, a as createBlockInstance, w, r as registerBlock, g as defineBlock, t as subscribeContext } from "./theme-state-BZplRS92.js";
+import { a as createEditorBridge, e as createSelectBlockMessage } from "./bridge-DQsM97cH.js";
+const TranslationContext = createContext("translation");
+function toStringRecord(input) {
+  if (input == null) return {};
+  return Object.fromEntries(
+    Object.entries(input).filter(([, value]) => typeof value === "string")
+  );
+}
+function createTranslationService(locales, options = {}) {
+  const loadedThemeDefaults = d({});
+  if (options.loadDefaultTranslations) {
+    let loadVersion = 0;
+    E(() => {
+      const locale = locales.locale.value;
+      const currentVersion = ++loadVersion;
+      void options.loadDefaultTranslations(locale).then((result) => toStringRecord(result)).catch(() => ({})).then((result) => {
+        if (currentVersion !== loadVersion) return;
+        loadedThemeDefaults.value = result;
+      });
+    });
+  }
+  return {
+    locale: locales.locale,
+    resolve(blockType, blockId, key) {
+      var _a, _b, _c;
+      const data = locales.catalogs.value;
+      const themeDefault = loadedThemeDefaults.value[key] ?? (data == null ? void 0 : data.theme.defaults[key]);
+      if (data == null) {
+        return themeDefault ?? key;
+      }
+      if (blockId && ((_a = data.blocks.overrides[blockId]) == null ? void 0 : _a[key]) !== void 0) {
+        return data.blocks.overrides[blockId][key];
+      }
+      const blockDefault = blockType != null ? (_b = data.blocks.defaults[blockType]) == null ? void 0 : _b[key] : void 0;
+      const mode = (blockType != null ? (_c = data.blocks.modes[blockType]) == null ? void 0 : _c[key] : void 0) ?? "override";
+      if (blockDefault !== void 0 && mode === "override") {
+        return blockDefault;
+      }
+      if (data.theme.overrides[key] !== void 0) {
+        return data.theme.overrides[key];
+      }
+      if (themeDefault !== void 0) {
+        return themeDefault;
+      }
+      if (blockDefault !== void 0) {
+        return blockDefault;
+      }
+      return key;
+    }
+  };
+}
+function getDefaultBlockForAction(actionType, actionConfig, blockId) {
+  const blockName = `action:${actionType}`;
+  const definedBlocks = getDefinedBlocks();
+  const exists = definedBlocks.some((b) => b.name === blockName);
+  if (!exists) {
+    throw new Error(
+      `No default block registered for action type "${actionType}". Expected a block named "${blockName}" to be registered in blocks-extensions.`
+    );
+  }
+  return createBlockInstance(blockName, { props: actionConfig, id: blockId });
+}
+function hasDefaultBlockForAction(actionType) {
+  const blockName = `action:${actionType}`;
+  return getDefinedBlocks().some((b) => b.name === blockName);
+}
+const WorkflowServiceContext = createContext("services/workflow");
+function createWorkflowApiAdapter(sdk) {
+  return {
+    async start(flowType, context, workflowId, dryRun) {
+      const { data } = await sdk.post("/customer/v1/workflows/start", {
+        flowType,
+        context,
+        ...workflowId ? { workflowId } : {},
+        ...dryRun ? { dryRun: true } : {}
+      });
+      return data;
+    },
+    async respond(runId, interactionId, responseType, responseData, expectedRunVersion, eventId) {
+      const { data } = await sdk.post(
+        "/customer/v1/workflows/{runId}/respond",
+        {
+          runId,
+          interactionId,
+          responseType,
+          responseData,
+          expectedRunVersion,
+          eventId
+        }
+      );
+      return data;
+    },
+    async getState(runId) {
+      const { data } = await sdk.get("/customer/v1/workflows/{runId}", {
+        runId
+      });
+      return data;
+    },
+    async cancel(runId) {
+      const { data } = await sdk.post("/customer/v1/workflows/{runId}/cancel", {
+        runId
+      });
+      return data;
+    }
+  };
+}
+function createWorkflowService(deps) {
+  const { api } = deps;
+  const editor = createEditorBridge();
+  const urlParams = typeof window !== "undefined" ? new URLSearchParams(window.location.search) : null;
+  const previewWorkflowTrigger = (urlParams == null ? void 0 : urlParams.get("trigger")) ?? null;
+  const previewStepId = (urlParams == null ? void 0 : urlParams.get("step-id")) ?? null;
+  const previewWorkflowId = (urlParams == null ? void 0 : urlParams.get("workflow-id")) ?? null;
+  const isEditorMode = editor.isEditorMode || previewWorkflowTrigger !== null;
+  const _state = d({
+    status: "idle",
+    flowType: null,
+    workflowId: null,
+    workflowVersion: null,
+    runId: null,
+    runVersion: null,
+    currentStepId: null,
+    currentInteraction: null,
+    error: null,
+    result: null,
+    flowParams: null,
+    invalidatedResources: [],
+    outcome: null,
+    completionData: null,
+    dryRun: null
+  });
+  const _backendInteractionId = d(null);
+  const _registeredRootBlocks = /* @__PURE__ */ new Set();
+  const isActive = w(() => _state.value.status === "active");
+  const isLoading = w(() => _state.value.status === "loading");
+  const isCompleted = w(() => _state.value.status === "completed");
+  const hasError = w(() => _state.value.status === "error");
+  const currentInteraction = w(() => _state.value.currentInteraction);
+  const canRespond = w(() => {
+    const interaction = _state.value.currentInteraction;
+    const backendId = _backendInteractionId.value;
+    if (!interaction || !backendId) return false;
+    return interaction.interactionId === backendId;
+  });
+  const currentStepInfo = w(() => {
+    const interaction = _state.value.currentInteraction;
+    if (!interaction) return null;
+    const actionConfig = deps.shopCurrencyCode ? { ...interaction.actionConfig, currency: deps.shopCurrencyCode } : interaction.actionConfig;
+    return {
+      interactionId: interaction.interactionId,
+      stepId: interaction.stepId,
+      actionType: interaction.actionType,
+      actionConfig,
+      availableResponses: interaction.availableResponses
+    };
+  });
+  function updateState(updates) {
+    _state.value = { ..._state.value, ...updates };
+  }
+  function hashString(value) {
+    let hash = 2166136261;
+    for (let index = 0; index < value.length; index += 1) {
+      hash ^= value.charCodeAt(index);
+      hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(36);
+  }
+  function shortenId(value, slugLength = 6) {
+    const compact = value.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const slug = (compact || "id").slice(0, slugLength);
+    return `${slug}-${hashString(value)}`;
+  }
+  function createStableStepBlockId(workflowId, stepId) {
+    return `wf-${shortenId(workflowId)}-${shortenId(stepId)}`;
+  }
+  function handleFlowResponse(data) {
+    var _a, _b, _c, _d, _e, _f;
+    const mergedInvalidated = [
+      ..._state.value.invalidatedResources,
+      ...data.invalidatedResources ?? []
+    ];
+    if (data.status === "waiting_interaction") {
+      const currentStepId = ((_a = data.pendingInteraction) == null ? void 0 : _a.stepId) ?? (isEditorMode ? (_c = (_b = data.interactiveSteps) == null ? void 0 : _b[0]) == null ? void 0 : _c.stepId : null);
+      _backendInteractionId.value = ((_d = data.pendingInteraction) == null ? void 0 : _d.interactionId) ?? null;
+      updateState({
+        status: "active",
+        workflowId: data.workflowId,
+        workflowVersion: data.workflowVersion,
+        runId: data.runId,
+        runVersion: data.runVersion,
+        currentStepId,
+        currentInteraction: data.pendingInteraction,
+        invalidatedResources: mergedInvalidated,
+        outcome: null
+      });
+      if (editor.isEditorMode) {
+        const overlayBlocks = deps.themeState.overlay.blocks.value;
+        const rootBlock = overlayBlocks[0];
+        const stepSlot = currentStepId ? (_e = rootBlock == null ? void 0 : rootBlock.slots) == null ? void 0 : _e[currentStepId] : null;
+        const stepBlock = Array.isArray(stepSlot) ? stepSlot[0] : null;
+        const blockId = stepBlock && typeof stepBlock === "object" && "id" in stepBlock ? stepBlock.id : null;
+        if (blockId) {
+          editor.sendMessage(
+            createSelectBlockMessage({ blockId }, blockId)
+          );
+        }
+      }
+    } else if (data.status === "completed") {
+      _backendInteractionId.value = null;
+      updateState({
+        status: "completed",
+        currentStepId: null,
+        currentInteraction: null,
+        runVersion: data.runVersion,
+        result: data.result || null,
+        invalidatedResources: mergedInvalidated,
+        outcome: data.outcome || null,
+        completionData: data.completionData || null
+      });
+    } else if (data.status === "failed") {
+      _backendInteractionId.value = null;
+      handleError(new Error(((_f = data.error) == null ? void 0 : _f.message) || "Flow failed"));
+    } else if (data.status === "cancelled") {
+      _backendInteractionId.value = null;
+      updateState({
+        status: "idle",
+        flowType: null,
+        workflowId: null,
+        workflowVersion: null,
+        runId: null,
+        runVersion: null,
+        currentStepId: null,
+        currentInteraction: null,
+        error: null,
+        result: null,
+        invalidatedResources: [],
+        outcome: null,
+        completionData: null
+      });
+    }
+  }
+  function handleError(error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    updateState({
+      status: "error",
+      error: message
+    });
+  }
+  function maybeApplyPreviewStep(flowType, data) {
+    var _a;
+    if (!previewWorkflowTrigger) return;
+    if (flowType !== previewWorkflowTrigger) return;
+    if (data.status !== "waiting_interaction") return;
+    const step = (_a = data.interactiveSteps) == null ? void 0 : _a.find(
+      (interactiveStep) => interactiveStep.stepId === previewStepId
+    );
+    if (!step) return;
+    updateState({
+      currentStepId: step.stepId,
+      currentInteraction: {
+        interactionId: `preview-${data.runId}-${step.stepId}`,
+        stepId: step.stepId,
+        actionType: step.actionType,
+        actionBehavior: "input",
+        actionConfig: step.actionConfig,
+        availableResponses: step.availableResponses,
+        presentedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  function initWorkflowRootBlock(data) {
+    if (_registeredRootBlocks.has(data.workflowId)) {
+      return;
+    }
+    const allSteps = data.interactiveSteps ?? (data.pendingInteraction ? [
+      {
+        stepId: data.pendingInteraction.stepId,
+        actionType: data.pendingInteraction.actionType,
+        actionConfig: data.pendingInteraction.actionConfig,
+        availableResponses: data.pendingInteraction.availableResponses
+      }
+    ] : []);
+    const slotProperties = {};
+    for (const step of allSteps) {
+      slotProperties[step.stepId] = {};
+    }
+    const presets = {};
+    for (const step of allSteps) {
+      presets[step.stepId] = {
+        label: step.stepId,
+        description: step.actionType,
+        state: step.stepId,
+        // @ts-expect-error Untyped
+        context: step
+      };
+    }
+    registerBlock(
+      defineBlock(`workflow:${data.workflowId}`, {
+        group: "workflow",
+        schema: {
+          type: "object",
+          properties: {
+            props: { type: "object" },
+            slots: {
+              type: "object",
+              properties: slotProperties
+            }
+          },
+          required: ["props", "slots"],
+          additionalProperties: true
+        },
+        initialValue: () => ({
+          props: {},
+          slots: Object.fromEntries(
+            allSteps.map((step) => [
+              step.stepId,
+              [
+                getDefaultBlockForAction(
+                  step.actionType,
+                  step.actionConfig,
+                  createStableStepBlockId(data.workflowId, step.stepId)
+                )
+              ]
+            ])
+          )
+        }),
+        presets,
+        renderer() {
+          return null;
+        }
+      })
+    );
+    _registeredRootBlocks.add(data.workflowId);
+  }
+  async function initWorkflowState(data) {
+    const { blocks } = await deps.themeState.resolve(
+      "overlay",
+      data.workflowId,
+      `workflow:${data.workflowId}`
+    );
+    if (blocks.length === 0) return;
+    editor.onBlockPresetChange(blocks[0].id, (preset) => {
+      if (!preset) {
+        return;
+      }
+      updateState({
+        // @ts-expect-error Untyped
+        currentStepId: preset.state,
+        // @ts-expect-error Untyped
+        currentInteraction: { ...preset == null ? void 0 : preset.context }
+      });
+    });
+  }
+  const service = {
+    // State signals (readonly)
+    state: _state,
+    /** True when the portal is running inside the Blocks Editor (editorMode dep
+     *  or ?trigger=... URL param). Consumers use this to suppress auto-start. */
+    isPreviewMode: isEditorMode,
+    // Computed signals
+    isActive,
+    isLoading,
+    isCompleted,
+    hasError,
+    canRespond,
+    currentInteraction,
+    currentStepInfo,
+    // Methods
+    async startFlow(flowType, context, workflowId) {
+      const isDryRun = isEditorMode;
+      updateState({
+        status: "loading",
+        error: null,
+        flowParams: context,
+        flowType,
+        dryRun: isDryRun
+      });
+      try {
+        const data = await api.start(
+          flowType,
+          context,
+          workflowId,
+          isDryRun || void 0
+        );
+        if (data.status === "no_workflow") {
+          service.reset();
+          return;
+        }
+        if (data.status === "completed_silently") {
+          updateState({
+            status: "completed",
+            currentStepId: null,
+            currentInteraction: null,
+            result: null,
+            invalidatedResources: data.invalidatedResources ?? [],
+            outcome: data.outcome || null,
+            completionData: data.completionData || null
+          });
+          return;
+        }
+        initWorkflowRootBlock(data);
+        await initWorkflowState(data);
+        handleFlowResponse(data);
+        maybeApplyPreviewStep(flowType, data);
+      } catch (error) {
+        handleError(error);
+      }
+    },
+    async respond(responseType, responseData) {
+      const { runId, runVersion, currentInteraction: currentInteraction2 } = _state.value;
+      if (!runId || !currentInteraction2) {
+        throw new Error("No active interaction to respond to");
+      }
+      updateState({ status: "loading" });
+      try {
+        const data = await api.respond(
+          runId,
+          currentInteraction2.interactionId,
+          responseType,
+          responseData,
+          runVersion ?? void 0
+        );
+        handleFlowResponse(data);
+      } catch (error) {
+        handleError(error);
+      }
+    },
+    async cancel() {
+      const { runId, status } = _state.value;
+      const isTerminal = status === "completed" || status === "error";
+      if (runId && !isTerminal) {
+        try {
+          const data = await api.cancel(runId);
+          if (data.outcome) {
+            updateState({
+              status: "completed",
+              flowType: null,
+              workflowId: null,
+              workflowVersion: null,
+              runId: null,
+              runVersion: null,
+              currentStepId: null,
+              currentInteraction: null,
+              error: null,
+              result: null,
+              flowParams: null,
+              invalidatedResources: data.invalidatedResources ?? [],
+              outcome: data.outcome || null,
+              dryRun: null
+            });
+            return;
+          }
+        } catch {
+        }
+      }
+      service.reset();
+    },
+    reset() {
+      _backendInteractionId.value = null;
+      updateState({
+        status: "idle",
+        flowType: null,
+        workflowId: null,
+        workflowVersion: null,
+        runId: null,
+        runVersion: null,
+        currentStepId: null,
+        currentInteraction: null,
+        error: null,
+        result: null,
+        flowParams: null,
+        invalidatedResources: [],
+        outcome: null,
+        completionData: null
+      });
+    },
+    async refresh() {
+      const { runId } = _state.value;
+      if (!runId) return;
+      try {
+        const data = await api.getState(runId);
+        handleFlowResponse(data);
+      } catch (error) {
+        handleError(error);
+      }
+    }
+  };
+  if (previewWorkflowTrigger) {
+    void service.startFlow(
+      previewWorkflowTrigger,
+      {},
+      previewWorkflowId ?? void 0
+    );
+  }
+  return service;
+}
+class JuoWorkflowElement extends HTMLElement {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "workflowService", null);
+    __publicField(this, "unsubscribeContext", null);
+    __publicField(this, "unsubscribeEffect", null);
+    /** Tracks which step is currently mounted to avoid unnecessary DOM teardown. */
+    __publicField(this, "renderedStepId", null);
+    /**
+     * Optional function to wrap rendered content (step blocks).
+     * Must be set before workflow becomes active for correct behavior.
+     */
+    __publicField(this, "blockWrapper", null);
+  }
+  connectedCallback() {
+    this.style.display = "contents";
+    this.unsubscribeContext = subscribeContext(
+      this,
+      WorkflowServiceContext,
+      (service) => {
+        this.workflowService = service;
+        this.setupSubscription();
+      }
+    );
+  }
+  disconnectedCallback() {
+    var _a, _b;
+    (_a = this.unsubscribeContext) == null ? void 0 : _a.call(this);
+    (_b = this.unsubscribeEffect) == null ? void 0 : _b.call(this);
+    this.unsubscribeContext = null;
+    this.unsubscribeEffect = null;
+    this.renderedStepId = null;
+  }
+  setupSubscription() {
+    var _a;
+    if (!this.workflowService) return;
+    (_a = this.unsubscribeEffect) == null ? void 0 : _a.call(this);
+    this.unsubscribeEffect = E(() => {
+      var _a2, _b;
+      const status = ((_a2 = this.workflowService) == null ? void 0 : _a2.state.value.status) ?? "idle";
+      const stepInfo = (_b = this.workflowService) == null ? void 0 : _b.currentStepInfo.value;
+      const stepId = (stepInfo == null ? void 0 : stepInfo.stepId) ?? null;
+      queueMicrotask(() => {
+        if (this.isConnected) {
+          this.render(status, stepId);
+        }
+      });
+    });
+  }
+  render(status, stepId) {
+    var _a;
+    if ((status === "active" || status === "loading") && stepId) {
+      if (this.renderedStepId !== stepId) {
+        this.innerHTML = "";
+        this.renderedStepId = stepId;
+        const extensionRoot = document.createElement(
+          "juo-extension-root"
+        );
+        extensionRoot.setAttribute("surface", "overlay");
+        extensionRoot.setAttribute("name", stepId);
+        extensionRoot.blockWrapper = this.blockWrapper;
+        this.appendChild(extensionRoot);
+      }
+      return;
+    }
+    this.innerHTML = "";
+    this.renderedStepId = null;
+    if (status === "error") {
+      const error = ((_a = this.workflowService) == null ? void 0 : _a.state.value.error) ?? "Unknown error";
+      this.dispatchEvent(
+        new CustomEvent("juo-workflow-error", {
+          bubbles: true,
+          composed: true,
+          detail: { error }
+        })
+      );
+    }
+  }
+}
+if (typeof customElements !== "undefined" && !customElements.get("juo-workflow")) {
+  customElements.define("juo-workflow", JuoWorkflowElement);
+}
+export {
+  TranslationContext as T,
+  WorkflowServiceContext as W,
+  createWorkflowService as a,
+  createWorkflowApiAdapter as b,
+  createTranslationService as c,
+  getDefaultBlockForAction as g,
+  hasDefaultBlockForAction as h
+};

package/dist/main.d.ts

@@ -0,0 +1,11 @@
+export type { Block, BlockInstance, BlockDefinition, BlockLocaleFile, BlockRenderer, BlockPreset, BlockPresets, } from './block';
+export { createBlockInstance, createBlockInstanceFromJSON, createBlockInstanceFromObject, createCeRenderer, defineBlock, defineBlockRuntime, getDefinedBlocks, withWrapper, registerBlock, SelectedBlockContext, createSelectedBlock, BlockWrapperEvent, serializeBlocks, onRegisterBlock, } from './block';
+export { ThemeStateContext, createThemeState, indexOverrides, type TranslationCatalogs, type TranslationMode, type TranslationScope, type TranslationOverride, type ThemeLocaleState, type ThemeState, type ThemeSurface, type ThemeSurfaceState, type GlobalStyles, type GlobalStyleColors, type ThemeType, DEFAULT_GLOBAL_STYLES, } from './theme-state';
+export { TranslationContext, createTranslationService, type TranslationServiceOptions, type TranslationService, } from './translation';
+export { ContextRequestEvent, ContextProvideEvent, type ContextCallback, createContext, injectContext, provideContext, subscribeContext, type ContextType, type UnknownContext, } from './context';
+export { StateContext, createState } from './state';
+export * from './utils';
+export * from './services';
+export * from './flows';
+export { Signal, signal, effect, computed, untracked, } from '@preact/signals-core';
+//# sourceMappingURL=main.d.ts.map

package/dist/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,KAAK,EACL,aAAa,EACb,eAAe,EACf,eAAe,EACf,aAAa,EACb,WAAW,EACX,YAAY,GACb,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,mBAAmB,EACnB,2BAA2B,EAC3B,6BAA6B,EAC7B,gBAAgB,EAChB,WAAW,EACX,kBAAkB,EAClB,gBAAgB,EAChB,WAAW,EACX,aAAa,EACb,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EACjB,eAAe,EACf,eAAe,GAChB,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,EACd,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,SAAS,EACd,qBAAqB,GACtB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,kBAAkB,EAClB,wBAAwB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,kBAAkB,GACxB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,KAAK,eAAe,EACpB,aAAa,EACb,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,KAAK,WAAW,EAChB,KAAK,cAAc,GACpB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEpD,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AAExB,OAAO,EACL,MAAM,EACN,MAAM,EACN,MAAM,EACN,QAAQ,EACR,SAAS,GACV,MAAM,sBAAsB,CAAC"}

package/dist/preact/block.d.ts

@@ -0,0 +1,21 @@
+import { ComponentType } from 'preact';
+import { BlockInstance } from '../main.ts';
+/**
+ * Creates a block renderer for Preact components
+ *
+ * @param component - Preact component to render
+ * @returns A block renderer function
+ */
+export declare function createPreactRenderer<P = any>(component: ComponentType<P>): (block: BlockInstance) => HTMLElement;
+/**
+ * Creates a custom element renderer for Preact components
+ *
+ * @param name - Custom element name
+ * @param component - Preact component to render
+ * @param options - Renderer options
+ * @returns A block renderer function
+ */
+export declare function createPreactCeRenderer<P = any>(name: string, component: ComponentType<P>, { shadowRoot }?: {
+    shadowRoot?: boolean;
+}): (block: BlockInstance) => HTMLElement;
+//# sourceMappingURL=block.d.ts.map

package/dist/preact/block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../src/preact/block.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAyBjD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,GAAG,GAAG,EAC1C,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC,GAC1B,CAAC,KAAK,EAAE,aAAa,KAAK,WAAW,CAgCvC;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,GAAG,GAAG,EAC5C,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC,EAC3B,EAAE,UAAiB,EAAE,GAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAO,GACnD,CAAC,KAAK,EAAE,aAAa,KAAK,WAAW,CAoEvC"}

package/dist/preact/block.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=block.test.d.ts.map

package/dist/preact/block.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block.test.d.ts","sourceRoot":"","sources":["../../src/preact/block.test.ts"],"names":[],"mappings":""}

package/dist/preact/bridge.d.ts

@@ -0,0 +1,11 @@
+import { PresetData, ExtractPresetState, ExtractPresetContext } from '../editor/bridge';
+type PresetChangeCallback<TPresets> = (preset: PresetData<ExtractPresetState<TPresets>, ExtractPresetContext<TPresets>> | null) => void;
+export interface UseBridgeOptions<TPresets = unknown> {
+    onPresetChange: PresetChangeCallback<TPresets>;
+}
+export interface BlockBridgeAPI {
+    readonly isEditorMode: boolean;
+}
+export declare function useBridge<TPresets = unknown>(options: UseBridgeOptions<TPresets>): BlockBridgeAPI;
+export {};
+//# sourceMappingURL=bridge.d.ts.map

package/dist/preact/bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../../src/preact/bridge.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EAC1B,MAAM,kBAAkB,CAAC;AAU1B,KAAK,oBAAoB,CAAC,QAAQ,IAAI,CACpC,MAAM,EAAE,UAAU,CAChB,kBAAkB,CAAC,QAAQ,CAAC,EAC5B,oBAAoB,CAAC,QAAQ,CAAC,CAC/B,GAAG,IAAI,KACL,IAAI,CAAC;AAEV,MAAM,WAAW,gBAAgB,CAAC,QAAQ,GAAG,OAAO;IAClD,cAAc,EAAE,oBAAoB,CAAC,QAAQ,CAAC,CAAC;CAChD;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;CAChC;AAED,wBAAgB,SAAS,CAAC,QAAQ,GAAG,OAAO,EAC1C,OAAO,EAAE,gBAAgB,CAAC,QAAQ,CAAC,GAClC,cAAc,CAiChB"}

package/dist/preact/context.d.ts

@@ -0,0 +1,31 @@
+import { ComponentChildren } from 'preact';
+import { ContextType, UnknownContext } from '../main.ts';
+import { Wrap } from '../shared/context';
+/**
+ * Context Provider component for Preact
+ *
+ * Provides the DOM element reference needed for Blocks context operations.
+ */
+export declare function ContextProvider({ children }: {
+    children: ComponentChildren;
+}): import('preact').VNode<import('preact').Attributes & {
+    value: HTMLElement | null;
+    children?: ComponentChildren;
+}>;
+/**
+ * Hook to provide context value in Preact components
+ *
+ * @param context - The context to provide
+ * @param init - The initial value for the context
+ */
+export declare function useProvideContext<C extends UnknownContext>(context: C, init: ContextType<C>): void;
+/**
+ * Hook to inject context value in Preact components
+ *
+ * @param context - The context to inject
+ * @returns The context value, with signals automatically converted to Preact state
+ */
+export declare function useContext<C extends UnknownContext>(context: C): Wrap<ContextType<C>>;
+export declare function useBlockId(): string | null;
+export type { Wrap } from '../shared/context';
+//# sourceMappingURL=context.d.ts.map

package/dist/preact/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/preact/context.ts"],"names":[],"mappings":"AASA,OAAO,EAAK,KAAK,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AACnD,OAAO,EACL,WAAW,EAGX,cAAc,EACf,MAAM,aAAa,CAAC;AAErB,OAAO,EAAe,KAAK,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAI3D;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,iBAAiB,CAAA;CAAE;;;GAiB5E;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,cAAc,EACxD,OAAO,EAAE,CAAC,EACV,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,GACnB,IAAI,CAON;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,cAAc,EACjD,OAAO,EAAE,CAAC,GACT,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAOtB;AAED,wBAAgB,UAAU,IAAI,MAAM,GAAG,IAAI,CAU1C;AAED,YAAY,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC"}