@r2digisolutions/components 0.1.6 → 0.2.0

package/dist/utils/canvasHistory.js

@@ -0,0 +1,48 @@
+const HISTORY_LIMIT = 80;
+export function serializeCanvasDoc(doc) {
+    return JSON.stringify(doc);
+}
+export function parseCanvasDoc(raw) {
+    return JSON.parse(raw);
+}
+export function createCanvasHistory(doc) {
+    const last = serializeCanvasDoc(doc);
+    return { past: [], future: [], last };
+}
+/** Push current `last` to past when document changes (skips no-ops). */
+export function pushCanvasHistory(state, nextDoc) {
+    const next = serializeCanvasDoc(nextDoc);
+    if (next === state.last)
+        return state;
+    return {
+        past: [...state.past, state.last].slice(-HISTORY_LIMIT),
+        future: [],
+        last: next
+    };
+}
+export function undoCanvasHistory(state) {
+    if (!state.past.length)
+        return null;
+    const prev = state.past[state.past.length - 1];
+    return {
+        state: {
+            past: state.past.slice(0, -1),
+            future: [state.last, ...state.future].slice(0, HISTORY_LIMIT),
+            last: prev
+        },
+        doc: parseCanvasDoc(prev)
+    };
+}
+export function redoCanvasHistory(state) {
+    if (!state.future.length)
+        return null;
+    const next = state.future[0];
+    return {
+        state: {
+            past: [...state.past, state.last].slice(-HISTORY_LIMIT),
+            future: state.future.slice(1),
+            last: next
+        },
+        doc: parseCanvasDoc(next)
+    };
+}

package/dist/utils/canvasWidget.d.ts

@@ -0,0 +1,81 @@
+import { type CanvasDocument, type CanvasExposedProp, type CanvasLayer, type CanvasWidgetDefinition } from './canvasDocument.js';
+import { deleteSubtree } from './canvasHierarchy.js';
+declare const EXPOSEABLE_FIELDS: readonly ["text", "fill", "src", "color", "opacity", "visible", "name", "fontSize", "borderRadius", "stroke", "strokeWidth", "textBackground", "objectFit"];
+export type CanvasExposeableField = (typeof EXPOSEABLE_FIELDS)[number];
+export declare function isExposeableField(field: string): field is CanvasExposeableField;
+export declare function createWidgetDefinition(partial?: Partial<Omit<CanvasWidgetDefinition, 'id'>> & {
+    id?: string;
+}): CanvasWidgetDefinition;
+/**
+ * Create a User Widget from selected scene layers (must share same parent).
+ * Replaces selection with a single widget instance.
+ */
+export declare function createWidgetFromSelection(doc: CanvasDocument, selectedIds: string[], name?: string): {
+    doc: CanvasDocument;
+    definitionId: string;
+    instanceId: string;
+} | null;
+/** Place a new instance of a widget definition into the document. */
+export declare function placeWidgetInstance(doc: CanvasDocument, definitionId: string, opts?: {
+    parentId?: string | null;
+    x?: number;
+    y?: number;
+    name?: string;
+}): CanvasDocument | null;
+/** Rename a widget definition (and matching instance names that still equal the old name). */
+export declare function renameWidgetDefinition(doc: CanvasDocument, definitionId: string, name: string): CanvasDocument;
+/** Duplicate a widget definition (new id, remapped layer ids). Does not place an instance. */
+export declare function duplicateWidgetDefinition(doc: CanvasDocument, definitionId: string): {
+    doc: CanvasDocument;
+    definitionId: string;
+} | null;
+/**
+ * When a blueprint artboard size changes, optionally resize all instances to match.
+ */
+export declare function syncInstanceSizesToDefinition(doc: CanvasDocument, definitionId: string): CanvasDocument;
+/**
+ * Resolve a widget instance into concrete layers (for render/export).
+ * Layer ids are prefixed so they don't collide with scene ids.
+ */
+export declare function resolveWidgetInstance(instance: CanvasLayer, definition: CanvasWidgetDefinition, idPrefix?: string): CanvasLayer[];
+/** Expand all widget instances in a layer list (nested widgets + named-slot injection). */
+export declare function flattenLayersWithWidgets(layers: CanvasLayer[], widgets: CanvasWidgetDefinition[], depth?: number): CanvasLayer[];
+/**
+ * Break / detach instance: inline resolved layers into the document and remove the instance.
+ */
+export declare function breakWidgetInstance(doc: CanvasDocument, instanceId: string): CanvasDocument;
+export declare function updateWidgetDefinition(doc: CanvasDocument, definitionId: string, updater: (d: CanvasWidgetDefinition) => CanvasWidgetDefinition): CanvasDocument;
+/** Remove a widget definition and all of its instances (including nested scene children). */
+export declare function deleteWidgetDefinition(doc: CanvasDocument, definitionId: string): CanvasDocument;
+export declare function setExposedProp(def: CanvasWidgetDefinition, targetLayerId: string, field: string, exposed: boolean, label?: string): CanvasWidgetDefinition;
+export declare function isPropExposed(def: CanvasWidgetDefinition | null | undefined, layerId: string, field: string): boolean;
+export declare function getExposedProp(def: CanvasWidgetDefinition | null | undefined, layerId: string, field: string): CanvasExposedProp | undefined;
+/** Blueprint default for an exposed prop (value on the target layer inside the definition). */
+export declare function getExposedFieldDefault(def: CanvasWidgetDefinition, prop: CanvasExposedProp): unknown;
+/** Instance override if set, otherwise the blueprint default. */
+export declare function resolveExposedPropValue(instance: CanvasLayer, def: CanvasWidgetDefinition, prop: CanvasExposedProp): unknown;
+/** Group exposed props by target layer for inspector headers. */
+export declare function groupExposedPropsByLayer(def: CanvasWidgetDefinition): {
+    layerId: string;
+    layerName: string;
+    props: CanvasExposedProp[];
+}[];
+export declare function setInstanceOverride(doc: CanvasDocument, instanceId: string, propId: string, value: unknown): CanvasDocument;
+export declare function documentAsWidgetEditSurface(doc: CanvasDocument, definitionId: string): {
+    width: number;
+    height: number;
+    background: string;
+    layers: CanvasLayer[];
+} | null;
+export declare function patchWidgetEditSurface(doc: CanvasDocument, definitionId: string, surface: {
+    width?: number;
+    height?: number;
+    background?: string;
+    layers?: CanvasLayer[];
+}): CanvasDocument;
+export declare function getNamedSlotsFromDefinition(def: CanvasWidgetDefinition | null | undefined): {
+    layerId: string;
+    name: string;
+}[];
+export declare function listFillableSlotsForInstance(doc: CanvasDocument, instanceId: string): string[];
+export { deleteSubtree };