@wix/public-editor-platform-interfaces 1.38.0 → 1.40.0

package/dist/Bindings.d.ts

@@ -1,83 +1,52 @@
-import { ProviderItem } from './Providers';
-export type UnbindAll = 'ALL';
-export interface BindingsMap {
-    [key: string]: PropertyBinding;
-}
-export type PropertyBinding = ContextItemBinding | MethodBinding;
-export declare enum BindingItemType {
-    ContextItem = "ContextItem",
-    Method = "Method"
+import { ProviderType } from './Providers';
+export declare const UNBIND_ALL: "ALL";
+export type UnbindAll = typeof UNBIND_ALL;
+export interface BindingProperties {
+    bindingsMap: ProviderBindingsMap;
+    displayName?: string;
+    providerIdentifier: string;
+    providerType: ProviderType;
 }
-export interface ContextItemBinding {
-    bindingItemType: BindingItemType.ContextItem;
+export type ProviderBindingsMap = Record<string, PropertyBinding>;
+export type PropertyBinding = MethodBinding | ProviderItemBinding;
+export interface ProviderItemBinding {
+    bindingItemType: BindingItemType.ItemBinding;
     displayName?: string;
     itemPath: string;
 }
 export interface MethodBinding {
-    bindingItemType: BindingItemType.Method;
+    bindingItemType: BindingItemType.MethodBinding;
     callOptions: CallOptions;
     displayName?: string;
     methodPath: string;
 }
-export type BindingArgument = ContextBindingArgument | FunctionBinding | StaticArgument;
+export declare enum BindingItemType {
+    ItemBinding = "ItemBinding",
+    MethodBinding = "MethodBinding"
+}
+export type BindingArgument = ProviderItemBindingArgument | StaticArgument;
 export interface CallOptions {
     arguments: BindingArgument[];
     asCallback: boolean;
 }
-export interface FunctionBinding extends CallOptions {
-    displayName?: string;
-    function: string;
-    functionLibraryType: string;
-    type: ArgumentType.FunctionBinding;
+export declare enum ArgumentType {
+    ProviderBinding = "ProviderBindingItem",
+    Static = "StaticArgItem"
 }
-export interface ContextBindingArgument {
-    contextItem: PropertyBinding;
-    contextProvider: string;
+export interface ProviderItemBindingArgument {
     displayName?: string;
-    type: ArgumentType.ContextBinding;
+    providerIdentifier: string;
+    providerItem: PropertyBinding;
+    providerType: ProviderType;
+    type: ArgumentType.ProviderBinding;
 }
 export interface StaticArgument {
     dataType: string;
     type: ArgumentType.Static;
     value: string;
 }
-export declare enum ArgumentType {
-    ContextBinding = "ContextBindingItem",
-    FunctionBinding = "FunctionBindingItem",
-    Static = "StaticArgItem"
-}
-export interface FunctionBindingsMap {
-    [key: string]: FunctionPropertyBinding;
-}
-export interface FunctionPropertyBinding {
-    callOptions: CallOptions;
-    function: string;
-}
-export interface BoundPropertiesPerProvider {
-    [key: string]: BoundProperties;
-}
-export type BoundProperties = ContextProviderBindings | FunctionLibraryBinding;
-export declare enum BindingType {
-    ContextProvider = "ContextProvider",
-    FunctionLibrary = "FunctionLibrary"
-}
-export interface ContextProviderBindings {
-    bindingsMap: BindingsMap;
-    bindingType: BindingType.ContextProvider;
-    displayName?: string;
-}
-export interface FunctionLibraryBinding {
-    bindingsMap: FunctionBindingsMap;
-    bindingType: BindingType.FunctionLibrary;
+export interface ListBindingsOptions {
+    includeDisplayNames?: boolean;
+    providerIdentifiers?: string[];
+    providerTypes?: ProviderType[];
 }
-export type Binding = {
-    bindings: BindingsMap;
-    providerType: string;
-};
-export type ListBindingsResponse = {
-    bindings: BoundProperties;
-    providerType: string;
-}[];
-export type BindingCandidate = ProviderItem & {
-    isBound: boolean;
-};

package/dist/Bindings.js

@@ -1,19 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BindingType = exports.ArgumentType = exports.BindingItemType = void 0;
+exports.ArgumentType = exports.BindingItemType = exports.UNBIND_ALL = void 0;
+exports.UNBIND_ALL = 'ALL';
 var BindingItemType;
 (function (BindingItemType) {
-    BindingItemType["ContextItem"] = "ContextItem";
-    BindingItemType["Method"] = "Method";
+    BindingItemType["ItemBinding"] = "ItemBinding";
+    BindingItemType["MethodBinding"] = "MethodBinding";
 })(BindingItemType || (exports.BindingItemType = BindingItemType = {}));
 var ArgumentType;
 (function (ArgumentType) {
-    ArgumentType["ContextBinding"] = "ContextBindingItem";
-    ArgumentType["FunctionBinding"] = "FunctionBindingItem";
+    ArgumentType["ProviderBinding"] = "ProviderBindingItem";
     ArgumentType["Static"] = "StaticArgItem";
 })(ArgumentType || (exports.ArgumentType = ArgumentType = {}));
-var BindingType;
-(function (BindingType) {
-    BindingType["ContextProvider"] = "ContextProvider";
-    BindingType["FunctionLibrary"] = "FunctionLibrary";
-})(BindingType || (exports.BindingType = BindingType = {}));

package/dist/Elements.d.ts

@@ -1,11 +1,65 @@
-export interface IElementBase<TType, TProps extends Record<string, any>> {
-    type: TType;
-    getProp: <K extends keyof TProps | string>(prop: K) => Promise<TProps[K] | null | undefined | void>;
-    setProp<K extends keyof TProps>(prop: K, value: TProps[K] | null | undefined): Promise<void>;
+import type { ElementData, ElementDataInput, ElementDataDefinitions, ElementStyles, ElementStylesUpdate, ElementStylesRemoval, ElementStyleDefinitions, ElementPresetDefinitions, ElementStateDefinitions, ElementLink, ElementDataValue } from './sdk';
+import type { BackgroundPickerOptions } from './Inputs';
+import type { SelectFontParams, SelectFontFamilyParams, SelectFontWeightParams, SelectMediaParams, SelectLinkParams, SelectColorParams, SelectTextThemeParams, IFontFamily, IFontWeight, IFontFamilyAndWeight } from './sdk/pickers';
+/**
+ * Unified element interface returned by `elements.getSelection()` (Classic / Studio)
+ * and structurally satisfied by the `element` singleton (Harmony).
+ *
+ * @remarks
+ * In Classic / Studio editors, builder-specific methods (`getStyles`, `getData`,
+ * `applyPreset`, pickers, etc.) return inert empty values. They are functional only
+ * when the component is selected in Harmony (Editor 3).
+ */
+export interface IElement {
+    /** Component type id. Populated in Classic/Studio (text|image|null). Always null in Harmony. */
+    type: string | null;
+    getProp<T = unknown>(prop: string): Promise<T | null | undefined | void>;
+    setProp<T = unknown>(prop: string, value: T | null | undefined): Promise<void>;
+    getData<T extends ElementData = ElementData>(): Promise<T>;
+    setData<T extends ElementData = ElementData>(values: ElementDataInput<T>): Promise<void>;
+    getResolvedData(options: {
+        dataItemKey: string;
+    }): Promise<ElementDataValue>;
+    getDataDefinitions(): Promise<ElementDataDefinitions>;
+    getStyles(): Promise<ElementStyles>;
+    setStyles(values?: ElementStylesUpdate): Promise<void>;
+    removeStyles(values?: ElementStylesRemoval): Promise<void>;
+    getStyleDefinitions(): Promise<ElementStyleDefinitions>;
+    getPresetDefinitions(): Promise<ElementPresetDefinitions>;
+    getAppliedPreset(): Promise<string | null>;
+    applyPreset(options: {
+        key: string;
+    }): Promise<void>;
+    getState(): Promise<string | null>;
+    setState(stateKey: string | null): Promise<void>;
+    getStateDefinitions(): Promise<ElementStateDefinitions>;
+    getDisplayGroupDefinitions(options?: {
+        filter?: {
+            groupType?: string;
+        };
+    }): Promise<Record<string, unknown>>;
+    getDisplayName(): Promise<string>;
+    onChange(callback: (patch: {
+        type: 'styles' | 'data' | 'state' | 'preset' | 'props' | 'manifest';
+        value: unknown;
+    }) => void): Promise<() => void>;
+    selectFont(params: SelectFontParams): Promise<IFontFamilyAndWeight | undefined>;
+    selectFontFamily(params: SelectFontFamilyParams): Promise<IFontFamily | undefined>;
+    selectFontWeight(params: SelectFontWeightParams): Promise<IFontWeight>;
+    selectMedia(params: SelectMediaParams): Promise<unknown>;
+    selectLink(params: SelectLinkParams): Promise<ElementLink | null | undefined>;
+    selectColor(params: SelectColorParams): Promise<string | undefined>;
+    selectBackground(options: BackgroundPickerOptions): Promise<unknown>;
+    selectTextTheme(params: SelectTextThemeParams): Promise<unknown>;
+    getArrayItemsSelectedIndex(options?: {
+        arrayItemsDisplayGroupKey?: string;
+    }): Promise<number>;
+    setArrayItemsSelectedIndex(options: {
+        index: number;
+        arrayItemsDisplayGroupKey?: string;
+    }): Promise<void>;
+    resetArrayItemsSelectedIndex(options?: {
+        arrayItemsDisplayGroupKey?: string;
+    }): Promise<void>;
+    getBiToken(): Promise<string>;
 }
-export type IElement = IElementBase<'text', {
-    text: string;
-}> | IElementBase<'image', {
-    src: string;
-    responsive: boolean;
-}> | IElementBase<null, Record<string, string | number | boolean>>;

package/dist/Providers.d.ts

@@ -1,30 +1,53 @@
+import { DataType, EditorFunction, TextEnum } from '@wix/app-extensions/trusted';
+export declare enum ProviderType {
+    Context = "Context",
+    FunctionLibrary = "FunctionLibrary",
+    Template = "Template"
+}
 export type Provider = {
-    attachState?: AttachState;
-    contextDependencies?: string[];
     displayName: string;
     items?: Record<string, ProviderItem>;
-    providerType: string;
-};
+    providerIdentifier: string;
+} & ({
+    attachState?: AttachState.Above | AttachState.None | AttachState.Self;
+    contextDependencies?: string[];
+    providerType: ProviderType.Context;
+} | {
+    attachState?: AttachState.Above | AttachState.Self;
+    providerType: ProviderType.Template;
+} | {
+    attachState?: AttachState.System;
+    providerType: ProviderType.FunctionLibrary;
+});
 type ProviderItemBase = {
     displayName: string;
     itemName: string;
-    providerType: string;
 };
 export type ProviderArrayItem = ProviderItemBase & {
     arrayItem: ProviderItem;
-    dataType: String;
+    dataType: DataType.arrayItems;
 };
 export type ProviderObjectItem = ProviderItemBase & {
-    dataType: String;
+    dataType: DataType.data;
     objectItem: Record<string, ProviderItem>;
 };
+export type ProviderFunctionItem = ProviderItemBase & {
+    dataType: DataType.function;
+    function?: EditorFunction;
+};
+export type ProviderTextEnumItem = ProviderItemBase & {
+    dataType: DataType.textEnum;
+    textEnum: TextEnum;
+};
 export type ProviderSimpleItem = ProviderItemBase & {
-    dataType: String;
+    dataType: Exclude<DataType, DataType.arrayItems | DataType.data | DataType.function | DataType.textEnum>;
 };
-export type ProviderItem = ProviderArrayItem | ProviderObjectItem | ProviderSimpleItem;
-export type AttachState = 'above' | 'none' | 'self';
-export interface AttachedProvider extends Provider {
-    attachState: AttachState;
+export type ProviderItem = ProviderArrayItem | ProviderFunctionItem | ProviderObjectItem | ProviderSimpleItem | ProviderTextEnumItem;
+export declare enum AttachState {
+    Above = "above",
+    None = "none",
+    Self = "self",
+    System = "system"
 }
 export type AttachStateFilter = boolean | {
     filterAttachedState?: AttachState[];
@@ -33,6 +56,7 @@ export type ListProvidersOptions = {
     includeAttachState?: AttachStateFilter;
     includeDependencies?: boolean;
     includeItems?: boolean;
-    providerTypes?: string[];
+    providerIdentifiers?: string[];
+    providerTypes?: ProviderType[];
 };
 export {};

package/dist/Providers.js

@@ -1,2 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachState = exports.ProviderType = void 0;
+var ProviderType;
+(function (ProviderType) {
+    ProviderType["Context"] = "Context";
+    ProviderType["FunctionLibrary"] = "FunctionLibrary";
+    ProviderType["Template"] = "Template";
+})(ProviderType || (exports.ProviderType = ProviderType = {}));
+var AttachState;
+(function (AttachState) {
+    AttachState["Above"] = "above";
+    AttachState["None"] = "none";
+    AttachState["Self"] = "self";
+    AttachState["System"] = "system";
+})(AttachState || (exports.AttachState = AttachState = {}));

package/dist/sdk/index.d.ts

@@ -2,3 +2,4 @@ export * from './data';
 export * from './styles';
 export * from './definitions';
 export * from './css-properties';
+export * from './pickers';

package/dist/sdk/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./data"), exports);
 __exportStar(require("./styles"), exports);
 __exportStar(require("./definitions"), exports);
 __exportStar(require("./css-properties"), exports);
+__exportStar(require("./pickers"), exports);

package/dist/sdk/pickers.d.ts

@@ -0,0 +1,97 @@
+import type { ElementLink } from './data';
+/** Represents a font family and its weight. */
+export interface IFontFamily {
+    /** The font family name. For example, 'Arial' or 'Helvetica Neue'. */
+    family: string;
+    /** The font weight. For example, '400' or 'bold'. */
+    weight: string;
+}
+/** Represents a font weight value. */
+export interface IFontWeight {
+    /** The font weight. For example, '400' or 'bold'. */
+    weight: string;
+}
+/** Combination of font family and weight properties. */
+export type IFontFamilyAndWeight = IFontFamily & IFontWeight;
+export type ISelectLinkSharedOptions = {
+    /** Identifier for the origin of the link selection (used for BI tracking). */
+    origin?: string;
+};
+/** Options for positioning a picker panel relative to a target element. */
+export type IPanelOptions = {
+    /** Where to place the picker panel relative to the target element. */
+    placement?: 'top' | 'bottom' | 'top-start' | 'bottom-start' | 'top-end' | 'bottom-end';
+    /** Vertical offset in pixels to shift the panel from its computed position. */
+    YShift?: number;
+};
+export type SelectFontParams = {
+    styleItemKey: string;
+} | {
+    selectedFontFamily?: IFontFamilyAndWeight;
+    target?: HTMLElement;
+    panelOptions?: IPanelOptions;
+    onChange?: (value: IFontFamilyAndWeight) => void;
+    onPreview?: (value: IFontFamilyAndWeight) => void;
+};
+export type SelectFontFamilyParams = {
+    styleItemKey: string;
+} | {
+    selectedFontFamily?: IFontFamily;
+    target?: HTMLElement;
+    panelOptions?: IPanelOptions;
+    onChange?: (value: IFontFamily) => void;
+    onPreview?: (value: IFontFamily) => void;
+};
+export type SelectFontWeightParams = {
+    fontFamilyStyleItemKey: string;
+    fontWeightStyleItemKey: string;
+} | {
+    fontStyleItemKey: string;
+} | {
+    fontFamily?: IFontFamily;
+    target?: HTMLElement;
+    onChange?: (value: IFontWeight) => void;
+};
+export type SelectMediaParams = {
+    dataItemKey: string;
+} | {
+    isMultiSelect?: boolean;
+    category?: string;
+};
+export type SelectLinkParams = {
+    dataItemKey: string;
+    options?: ISelectLinkSharedOptions;
+} | {
+    value?: ElementLink;
+    options?: ISelectLinkSharedOptions & {
+        linkTypes?: string[];
+    };
+};
+export type SelectColorParams = {
+    styleItemKey: string;
+} | {
+    initialValue?: string;
+    mode?: ('solid' | 'gradient')[];
+    showBrand?: boolean;
+    showCustom?: boolean;
+    showAdvancedSettings?: boolean;
+    showOpacity?: boolean;
+    position?: {
+        x: number;
+        y: number;
+    };
+    biData?: {
+        origin: string;
+    };
+    onChange?: (color: string) => void;
+    onApply?: (color: string) => void;
+    onClose?: () => void;
+    onCancel?: () => void;
+};
+export type SelectTextThemeParams = {
+    target?: HTMLElement;
+    initialValue?: {
+        font?: string;
+        color?: string;
+    };
+};

package/dist/sdk/pickers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/public-editor-platform-interfaces",
-  "version": "1.38.0",
+  "version": "1.40.0",
   "license": "UNLICENSED",
   "contributors": [
     {
@@ -23,6 +23,7 @@
     "*.{js,ts}": "yarn lint"
   },
   "dependencies": {
+    "@wix/app-extensions": "^1.0.29",
     "@wix/sdk-types": "^1.14.0"
   },
   "devDependencies": {
@@ -51,5 +52,5 @@
       ]
     }
   },
-  "falconPackageHash": "4844f880d36f8a57c20c081b07a678a6a6f957e5344d551778a412de"
+  "falconPackageHash": "a8c951ca90455f089a3982bab36d21f4e7525ffa07a5eb1201a8378e"
 }