@edifice.io/react 2.0.0-develop-rc.14 → 2.0.0-develop-rc.16

package/dist/modules/multimedia/ImageEditor/components/ImageEditorToolbar.js

@@ -0,0 +1,72 @@
+import { jsx } from "react/jsx-runtime";
+import { useState } from "react";
+import { useTranslation } from "react-i18next";
+import SvgIconBlur from "../../../icons/components/IconBlur.js";
+import SvgIconCrop from "../../../icons/components/IconCrop.js";
+import SvgIconReset from "../../../icons/components/IconReset.js";
+import SvgIconUndo from "../../../icons/components/IconUndo.js";
+import { Toolbar } from "../../../../components/Toolbar/Toolbar.js";
+const ImageEditorToolbar = ({
+  historyCount,
+  handle
+}) => {
+  const {
+    t
+  } = useTranslation(), [action, setAction] = useState(void 0), handleAndSave = (action2) => {
+    setAction(action2), handle(action2);
+  }, ImageEditorItems = [{
+    type: "button",
+    name: "undo",
+    props: {
+      color: "tertiary",
+      leftIcon: /* @__PURE__ */ jsx(SvgIconUndo, {}),
+      "aria-label": t("cancel"),
+      children: t("cancel"),
+      onClick: () => handleAndSave("UNDO"),
+      disabled: historyCount === 0
+    },
+    tooltip: t("cancel")
+  }, {
+    type: "divider",
+    name: "div-1"
+  }, {
+    type: "button",
+    name: "reset",
+    props: {
+      color: "tertiary",
+      leftIcon: /* @__PURE__ */ jsx(SvgIconReset, {}),
+      "aria-label": t("rotate"),
+      children: t("rotate"),
+      onClick: () => handleAndSave("ROTATE")
+    },
+    tooltip: t("rotate")
+  }, {
+    type: "button",
+    name: "crop",
+    props: {
+      color: "tertiary",
+      leftIcon: /* @__PURE__ */ jsx(SvgIconCrop, {}),
+      "aria-label": t("crop"),
+      children: t("crop"),
+      className: action === "CROP" ? "is-selected" : "",
+      onClick: () => handleAndSave("CROP")
+    },
+    tooltip: t("crop")
+  }, {
+    type: "button",
+    name: "blur",
+    props: {
+      color: "tertiary",
+      leftIcon: /* @__PURE__ */ jsx(SvgIconBlur, {}),
+      "aria-label": t("blur"),
+      children: t("blur"),
+      className: action === "BLUR" ? "is-selected" : "",
+      onClick: () => handleAndSave("BLUR")
+    },
+    tooltip: t("blur")
+  }];
+  return /* @__PURE__ */ jsx(Toolbar, { variant: "no-shadow", align: "left", isBlock: !0, items: ImageEditorItems });
+};
+export {
+  ImageEditorToolbar as default
+};

package/dist/modules/multimedia/ImageEditor/effects/blur.d.ts

@@ -0,0 +1,19 @@
+import * as PIXI from "pixi.js";
+/**
+ * This function start the blur controler
+ * - drawing cursor
+ * - listening mouse move to move cursor
+ * - listening
+ *
+ * @param application
+ * @param param1
+ */
+export declare function start(application: PIXI.Application, { spriteName }: {
+    spriteName: string;
+}): void;
+/**
+ * This function remove cursor and all mouse event listeners
+ *
+ * @param application the PIXI.Application context
+ */
+export declare function stop(application: PIXI.Application): void;

package/dist/modules/multimedia/ImageEditor/effects/blur.js

@@ -0,0 +1,72 @@
+import * as PIXI from "pixi.js";
+import { aggregate } from "../utilities/aggregate.js";
+import { getApplicationScale } from "./misc.js";
+const BRUSH_SIZE = 20, DEBOUNCE = 50, CURSOR_NAME = "BRUSH_CURSOR";
+function drawBrush(points, scale) {
+  const container = new PIXI.Graphics();
+  for (const point of points)
+    point && (container.beginFill(16777215, 1), container.drawCircle(point.x, point.y, BRUSH_SIZE / scale), container.lineStyle(0), container.endFill());
+  return container;
+}
+function drawBlurListener(application, {
+  spriteName
+}) {
+  return aggregate(DEBOUNCE, (event) => application.stage.toLocal(event.global), (points) => {
+    const child = application.stage.getChildByName(spriteName), scale = getApplicationScale(application);
+    if (child == null) return;
+    const newSprite = new PIXI.Sprite(child.texture);
+    newSprite.filters = [
+      new PIXI.BlurFilter(
+        8,
+        // PIXI Default value for strength of the blur effect
+        4,
+        // Quality of the blur effect depending on the scale (4 is the PIXI default value)
+        Math.min(scale, 1)
+      )
+      // Resolution of the blur effect depending on the scale
+    ], newSprite.width = child.width, newSprite.height = child.height, newSprite.scale = new PIXI.Point(1, 1), newSprite.anchor = child.anchor, newSprite.mask = drawBrush(points, scale), child.addChild(newSprite);
+  });
+}
+function drawCursor(application) {
+  removeCursor(application);
+  const scale = getApplicationScale(application), circle = new PIXI.Graphics();
+  return circle.lineStyle(Math.max(1, 1 / scale), 16711680), circle.drawCircle(0, 0, BRUSH_SIZE / scale), circle.endFill(), circle.name = CURSOR_NAME, application.stage.addChild(circle), circle;
+}
+function removeCursor(application) {
+  const child = application.stage.getChildByName(CURSOR_NAME);
+  child && child.removeFromParent();
+}
+function moveCursorListener(application) {
+  return (event) => {
+    if (!application) return;
+    const point = application.stage.toLocal(event.global), child = application.stage.getChildByName(CURSOR_NAME, !0);
+    child && (child.position.x = point.x, child.position.y = point.y);
+  };
+}
+function start(application, {
+  spriteName
+}) {
+  application.stage.interactive = !0;
+  const cursor = drawCursor(application), cursorListener = moveCursorListener(application);
+  application.stage.on("pointermove", cursorListener);
+  const blurListener = drawBlurListener(application, {
+    spriteName
+  });
+  application.stage.on("pointerdown", () => {
+    application.stage.on("pointermove", blurListener);
+  });
+  const stopListening = () => {
+    var _a;
+    (_a = application == null ? void 0 : application.stage) == null || _a.off("pointermove", blurListener);
+  };
+  globalThis.addEventListener("pointerup", stopListening), cursor.once("destroyed", () => {
+    globalThis.removeEventListener("pointerup", stopListening);
+  });
+}
+function stop(application) {
+  removeCursor(application), application.stage.off("pointerdown"), application.stage.off("pointermove");
+}
+export {
+  start,
+  stop
+};

package/dist/modules/multimedia/ImageEditor/effects/crop.d.ts

@@ -0,0 +1,28 @@
+import * as PIXI from "pixi.js";
+export type CornerType = "TOP_LEFT" | "TOP_RIGHT" | "BOTTOM_LEFT" | "BOTTOM_RIGHT";
+/**
+ * This function draw all graphics controls used to crop an image:
+ * - 4 corners to select the cropped area
+ * - A background with an transparent backdrop effect
+ * - A mask applied to the original image
+ *
+ * @param application The PIXI.Application context
+ * @param {spriteName:string} {spriteName} The sprite name identifying the original image
+ */
+export declare function start(application: PIXI.Application, { spriteName }: {
+    spriteName: string;
+}): void;
+/**
+ * This function remove all graphics controls if exists. And it also remove any mouse event on this stage
+ *
+ * @param application The PIXI.Application context
+ */
+export declare function stop(application: PIXI.Application): void;
+/**
+ * This function apply a crop to the imageSrc and return the result as a PIXI.Sprite object
+ *
+ * @param application
+ * @param imageSrc a string URI of the image to crop
+ * @returns a PIXI.Sprite with a imageSrc cropped or undefined if the image has not been cropped
+ */
+export declare function save(application: PIXI.Application): PIXI.Sprite | undefined;

package/dist/modules/multimedia/ImageEditor/effects/misc.d.ts

@@ -0,0 +1,154 @@
+import * as PIXI from "pixi.js";
+export declare const DEFAULT_SPRITE_NAME = "image";
+/**
+ * A structure that define all setting of an image
+ * - positon
+ * - scale
+ * - size
+ * - size of the stage
+ */
+export interface ImageSettings {
+    stage: {
+        size: {
+            width: number;
+            height: number;
+        };
+        scale: {
+            x: number;
+            y: number;
+        };
+    };
+    sprite: {
+        rotation: number;
+        size: {
+            width: number;
+            height: number;
+        };
+        scale: {
+            x: number;
+            y: number;
+        };
+        position: {
+            x: number;
+            y: number;
+        };
+        anchor: {
+            x: number;
+            y: number;
+        };
+    };
+}
+/**
+ *  This function update the image content using Blob datasource
+ *
+ * @param application the PIXI.Application context
+ * @param param.spriteName the name of the sprite in the context
+ * @param param.imgDatasource the img data could be one of: string url, HTMLImageElement, PIXI.Sprite
+ * @param param.stageSize?: { width: number; height: number };
+ * @param param.spriteSize?: { width: number; height: number };
+ */
+export declare function updateImageFromBlob(application: PIXI.Application, { spriteName, imgDatasource, settings, }: {
+    spriteName: string;
+    imgDatasource: Blob;
+    settings?: ImageSettings;
+}): Promise<PIXI.Sprite | null>;
+/**
+ *  This function update the image content for the sprite in the PIXI.Application context
+ *
+ * @param application the PIXI.Application context
+ * @param param.spriteName the name of the sprite in the context
+ * @param param.imgDatasource the img data could be one of: string url, HTMLImageElement, PIXI.Sprite
+ * @param param.spriteSize
+ * @param param.stageSize
+ */
+export declare function updateImage(application: PIXI.Application, { spriteName, imgDatasource, settings, }: {
+    spriteName: string;
+    imgDatasource: string | HTMLImageElement | PIXI.Sprite;
+    settings?: ImageSettings;
+}): Promise<void>;
+/**
+ * This function resize the sprite according to the container width
+ *
+ * @param application The PIXI.Application context
+ * @param sprite The sprite object representing the image to resize
+ */
+export declare function autoResize(application: PIXI.Application, sprite: PIXI.Sprite): void;
+export declare function constraintSize(size: {
+    width: number;
+    height: number;
+}, constraints: {
+    width: {
+        max: number;
+        min: number;
+    };
+    height: {
+        max: number;
+        min: number;
+    };
+}): {
+    width: number;
+    height: number;
+};
+/**
+ * This function transform the stage into a blob
+ *
+ * @param application the PIXI.Application context
+ * @returns A promise of the generated blob
+ */
+export declare function saveAsBlob(application: PIXI.Application): Promise<Blob>;
+/**
+ * This function transform the stage into a data URL encoded image
+ *
+ * @param application the PIXI.Application context
+ * @returns the generated image as Data URL or undefined if failed
+ */
+export declare function saveAsDataURL(application: PIXI.Application): string | undefined;
+/**
+ * Calculates the scale percentage for a PIXI.Sprite or the application view based on the parent container's dimensions.
+ * @param application - The PIXI.Application instance.
+ * @param sprite - The PIXI.Sprite instance (optional).
+ * @returns The scale percentage.
+ */
+export declare function getApplicationScale(application: PIXI.Application): number;
+export declare function toBlob(application: PIXI.Application): Promise<Blob>;
+export declare function createImageSettings({ application, sprite, }: {
+    sprite: PIXI.Sprite;
+    application: PIXI.Application;
+}): {
+    sprite: {
+        rotation: number;
+        size: {
+            width: number;
+            height: number;
+        };
+        position: {
+            x: number;
+            y: number;
+        };
+        scale: {
+            x: number;
+            y: number;
+        };
+        anchor: {
+            x: number;
+            y: number;
+        };
+    };
+    stage: {
+        size: {
+            width: number;
+            height: number;
+        };
+        scale: {
+            x: number;
+            y: number;
+        };
+    };
+};
+export declare function trimStage(application: PIXI.Application, sprite: PIXI.Sprite): void;
+export declare function resizeStage({ application, sprite, newHeight, newWidth, }: {
+    newHeight: number;
+    newWidth: number;
+    application: PIXI.Application;
+    sprite: PIXI.Sprite;
+}): void;

package/dist/modules/multimedia/ImageEditor/effects/resize.d.ts

@@ -0,0 +1,25 @@
+import * as PIXI from "pixi.js";
+/**
+ * Draw all graphical object to control the resize
+ *
+ * @param application the PIXI.Application context
+ * @param spriteName the name of the sprite representing the image
+ */
+export declare function start(application: PIXI.Application, spriteName: string): void;
+/**
+ * If {saveChanges} is true remove all graphical controls then resize the sprite
+ * If {saveChanges} is false remove all graphical controls and keep original size
+ *
+ * @param application the PIXI.Application context
+ * @param param.saveChanges true if we should save the resize
+ * @param param.spriteName the name of the sprite representing the original image
+ */
+export declare function stop(application: PIXI.Application): void;
+/**
+ *
+ * @param application the PIXI.Application context
+ * @param spriteName  the name of the sprite representing the image
+ * @param size the target size of the image {width, height}
+ * @returns a PIXI.Sprite with a image resized or undefined if not found
+ */
+export declare function save(application: PIXI.Application): PIXI.Sprite | undefined;

package/dist/modules/multimedia/ImageEditor/effects/rotate.d.ts

@@ -0,0 +1,8 @@
+import * as PIXI from "pixi.js";
+/**
+ * This function rotate the sprite by adding PI/2
+ *
+ * @param application The PIXI.Application context
+ * @param spriteName The name of the sprite representing the image
+ */
+export declare function rotate(application: PIXI.Application, spriteName: string): Promise<void>;

package/dist/modules/multimedia/ImageEditor/hooks/useHistoryTool.d.ts

@@ -0,0 +1,32 @@
+import { ImageSettings } from '../effects/misc';
+import * as PIXI from "pixi.js";
+/**
+ * Defined the structure of the backup in history
+ */
+export interface HistoryState extends ImageSettings {
+    backup: Promise<Blob>;
+}
+export interface UseHistoryToolsProps {
+    maxSize?: number;
+    application?: PIXI.Application;
+    spriteName: string;
+    onRestore: (img: Blob, state: HistoryState) => void;
+}
+/**
+ * This hook expose all the functions needed for historizing actions:
+ * - historize: Create a backup
+ * - restore: Restore a backup
+ * - historyCount: How much states stored in history
+ *
+ * @param param.maxSize the maximum size of the history
+ * @param param.application the PIXI.Application context
+ * @param param.spriteName the sprite name of the edited image
+ * @param param.onRestore a callback called when a backup is restored
+ * @returns all functions needed for managing history
+ */
+declare const useHistoryTool: ({ maxSize, application, spriteName, onRestore, }: UseHistoryToolsProps) => {
+    historyCount: number;
+    restore: () => Promise<void>;
+    historize: <T extends (...args: any[]) => any>(callback: T) => Promise<any>;
+};
+export default useHistoryTool;

package/dist/modules/multimedia/ImageEditor/hooks/useImageEditor.d.ts

@@ -0,0 +1,29 @@
+import * as PIXI from "pixi.js";
+/**
+ * This hook expose all the functions available for the pixi editor:
+ * - all the effects (crop, resize, rotate, blur)
+ * - historize every action
+ * - backup functions
+ *
+ * @param args.spriteName The spriteName of the original image
+ * @param args.imageSrc The URL of the image to edit
+ * @returns all the action available for the image editor
+ */
+export default function useImageEditor({ imageSrc, spriteName, }: {
+    imageSrc: string;
+    spriteName?: string;
+}): {
+    historyCount: number;
+    setApplication: import('react').Dispatch<import('react').SetStateAction<PIXI.Application<PIXI.ICanvas> | undefined>>;
+    restore: () => Promise<void>;
+    stopCrop: (save: boolean) => void;
+    stopBlur: () => void;
+    stopResize: (save: boolean) => void;
+    startResize: () => Promise<void>;
+    startCrop: () => Promise<void>;
+    startBlur: () => Promise<void>;
+    rotate: () => Promise<void>;
+    toBlob: () => Promise<Blob | undefined>;
+    toDataURL: () => string | undefined;
+    loading: boolean;
+};

package/dist/modules/multimedia/ImageEditor/hooks/useImageEffects.d.ts

@@ -0,0 +1,23 @@
+import * as PIXI from "pixi.js";
+export interface UseImageEffectsProps {
+    spriteName: string;
+    application?: PIXI.Application;
+    onSave(sprite: PIXI.Sprite): void;
+}
+/**
+ * This hook expose all effects of the pixi editor
+ *
+ * @param args.spriteName The spriteName of the original image
+ * @param args.application The PIXI.Application context
+ * @param args.onSave A callback called when the sprite changes
+ * @returns all the action available for the image editor
+ */
+export default function useImageEffects({ application, spriteName, onSave, }: UseImageEffectsProps): {
+    rotate: () => Promise<void>;
+    startCrop: () => void;
+    stopCrop: (save: boolean) => void;
+    startBlur: () => void;
+    stopBlur: () => void;
+    startResize: () => void;
+    stopResize: (save: boolean) => void;
+};

package/dist/modules/multimedia/ImagePicker/ImagePicker.d.ts

@@ -0,0 +1,46 @@
+import { ComponentPropsWithRef } from 'react';
+import { IWebApp } from '@edifice.io/ts-client';
+export interface ImagePickerProps extends ComponentPropsWithRef<"input"> {
+    /**
+     * Accessible description of the add button
+     */
+    addButtonLabel: string;
+    /**
+     * Accessible description of the delete button
+     */
+    deleteButtonLabel: string;
+    /**
+     * Provide a default image as placeholder
+     */
+    src?: string;
+    /**
+     * Pathe element select in WorkSpace
+     */
+    libraryMedia: string;
+    /**
+     * Element select in WorkSpace
+     */
+    mediaLibraryRef: any;
+    /**
+     * To show the icon of an application
+     */
+    app?: IWebApp | undefined;
+    appCode?: string;
+    /**
+     * Optional class for styling purpose
+     */
+    className?: string;
+    /**
+     * Callback when uploading image
+     */
+    onUploadImage: (file: File | string) => void;
+    /**
+     * Callback when deleting image
+     */
+    onDeleteImage: () => void;
+}
+declare const ImagePicker: {
+    ({ addButtonLabel, deleteButtonLabel, src, className, mediaLibraryRef, libraryMedia, app, onUploadImage, onDeleteImage, }: ImagePickerProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default ImagePicker;

package/dist/modules/multimedia/ImagePicker/ImagePicker.js

@@ -0,0 +1,40 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import clsx from "clsx";
+import SvgIconDelete from "../../icons/components/IconDelete.js";
+import SvgIconEdit from "../../icons/components/IconEdit.js";
+import IconButton from "../../../components/Button/IconButton.js";
+import Avatar from "../../../components/Avatar/Avatar.js";
+import AppIcon from "../../../components/AppIcon/AppIcon.js";
+const ImagePicker = ({
+  addButtonLabel = "Add image",
+  deleteButtonLabel = "Delete image",
+  src,
+  className,
+  mediaLibraryRef,
+  libraryMedia,
+  app,
+  onUploadImage,
+  onDeleteImage
+}) => {
+  const [preview, setPreview] = useState(src || "");
+  useEffect(() => {
+    libraryMedia && (setPreview(libraryMedia), onUploadImage(libraryMedia));
+  }, [libraryMedia]);
+  const handleClick = () => {
+    var _a;
+    (_a = mediaLibraryRef.current) == null || _a.show("image");
+  }, handleClean = () => {
+    setPreview(""), onDeleteImage();
+  }, classes = clsx("image-input", className);
+  return /* @__PURE__ */ jsxs("div", { id: "image-input", className: classes, children: [
+    /* @__PURE__ */ jsxs("div", { className: "image-input-actions gap-8", children: [
+      /* @__PURE__ */ jsx(IconButton, { "aria-label": addButtonLabel, color: "tertiary", icon: /* @__PURE__ */ jsx(SvgIconEdit, {}), onClick: handleClick, type: "button", variant: "ghost" }),
+      /* @__PURE__ */ jsx(IconButton, { "aria-label": deleteButtonLabel, color: "danger", disabled: !preview, icon: /* @__PURE__ */ jsx(SvgIconDelete, {}), onClick: handleClean, type: "button", variant: "ghost" })
+    ] }),
+    preview ? /* @__PURE__ */ jsx(Avatar, { alt: "", src: preview, size: "xl" }) : /* @__PURE__ */ jsx(AppIcon, { app, iconFit: "ratio", size: "160", variant: "rounded" })
+  ] });
+};
+export {
+  ImagePicker as default
+};

package/dist/modules/multimedia/ImagePicker/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ImagePicker';
+export { default as ImagePickerWorkspace } from './ImagePicker';

package/dist/modules/multimedia/Linker/ExternalLinker/ExternalLinker.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Properties for the ExternalLink.
+ */
+export interface IExternalLink {
+    /** Link Url */
+    url: string;
+    /** Link text for the llink display */
+    text?: string;
+    /** Link target (default: _blank) */
+    target?: "_blank";
+}
+/**
+ * Properties for the ExternalLinker react component.
+ */
+export type ExternalLinkerProps = {
+    /** Default link to update. */
+    link?: Partial<IExternalLink>;
+    /**
+     * Set true if the user select multiple nodes. (note simple text selection)
+     */
+    multiNodeSelected?: boolean;
+    /** Target */
+    target?: "_blank";
+    /** Notify when the user change any link information */
+    onChange?: (link?: IExternalLink) => void;
+};
+declare const ExternalLinker: ({ link, onChange, multiNodeSelected, }: ExternalLinkerProps) => import("react/jsx-runtime").JSX.Element;
+export default ExternalLinker;

package/dist/modules/multimedia/Linker/ExternalLinker/ExternalLinker.js

@@ -0,0 +1,45 @@
+import { jsx, Fragment, jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { useTranslation } from "react-i18next";
+import { StringUtils } from "@edifice.io/utilities";
+import useToggle from "../../../../hooks/useToggle/useToggle.js";
+import FormControl from "../../../../components/Form/FormControl.js";
+import Label from "../../../../components/Label/Label.js";
+import Input from "../../../../components/Input/Input.js";
+import Checkbox from "../../../../components/Checkbox/Checkbox.js";
+const ExternalLinker = ({
+  link,
+  onChange,
+  multiNodeSelected = !1
+}) => {
+  const {
+    t
+  } = useTranslation(), [linkText, setLinkText] = useState((link == null ? void 0 : link.text) || ""), [linkURL, setLinkURL] = useState((link == null ? void 0 : link.url) || ""), [isBlankTarget, toggleBlankTarget] = useToggle(link ? link.target === "_blank" : !0);
+  return useEffect(() => {
+    multiNodeSelected && (link != null && link.text) && setLinkText(link.text.slice(0, 20) + "...");
+  }, [multiNodeSelected, link]), useEffect(() => {
+    if (!linkURL.length) {
+      onChange == null || onChange();
+      return;
+    }
+    const newLink = {
+      url: linkURL,
+      text: multiNodeSelected ? link == null ? void 0 : link.text : linkText || linkURL,
+      target: isBlankTarget ? "_blank" : void 0
+    };
+    !StringUtils.isLocalURL(linkURL) && !StringUtils.startWithHttp(linkURL) && (newLink.url = "http://" + linkURL), onChange == null || onChange(newLink);
+  }, [linkText, linkURL, isBlankTarget]), /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsxs("div", { className: "d-flex flex-column flex-fill gap-24", children: [
+    /* @__PURE__ */ jsxs(FormControl, { id: "linkText", isOptional: !0, children: [
+      /* @__PURE__ */ jsx(Label, { children: t("bbm.linker.ext.text") }),
+      /* @__PURE__ */ jsx(Input, { type: "text", placeholder: t("bbm.linker.ext.text.placeholder"), size: "md", disabled: multiNodeSelected, value: linkText, onChange: (e) => setLinkText(e.target.value) })
+    ] }),
+    /* @__PURE__ */ jsxs(FormControl, { id: "linkUrl", isRequired: !0, children: [
+      /* @__PURE__ */ jsx(Label, { children: t("bbm.linker.ext.url") }),
+      /* @__PURE__ */ jsx(Input, { type: "text", placeholder: t("bbm.linker.ext.url.placeholder"), size: "md", value: linkURL, onChange: (e) => setLinkURL(e.target.value) })
+    ] }),
+    /* @__PURE__ */ jsx(Checkbox, { label: t("bbm.linker.open.tab"), onChange: () => toggleBlankTarget(), checked: isBlankTarget })
+  ] }) });
+};
+export {
+  ExternalLinker as default
+};

package/dist/modules/multimedia/Linker/InternalLinker/InternalLinker.d.ts

@@ -0,0 +1,37 @@
+import { App, ILinkedResource } from '@edifice.io/ts-client';
+/**
+ * Definition of an internal link.
+ */
+type ApplicationOption = {
+    /** Icon to display */
+    icon?: JSX.Element;
+    /** Application code */
+    application: string;
+    /** Display name */
+    displayName: string;
+};
+/**
+ * Properties for the InternalLinker react component.
+ */
+export interface InternalLinkerProps {
+    /** Currently running application */
+    appCode: App;
+    /** When defined, preloads and displays this type of resources. */
+    defaultAppCode?: App | null;
+    /** When defined, selects this resource (defaultApp must be specified) */
+    defaultResourceId?: string | null;
+    /** Notify when the user selects an application in the dropdown */
+    onChange?: (application?: ApplicationOption) => void;
+    /** Notify when resources selection changes */
+    onSelect?: (resources: ILinkedResource[]) => void;
+    /** Whether to allow multiple resources selection */
+    multiple: boolean | undefined;
+    /** List of resources to display */
+    resourceList?: ILinkedResource[];
+    /** List of applications to display */
+    applicationList?: ApplicationOption[];
+    /** Whether to show the application selector */
+    showApplicationSelector?: boolean;
+}
+declare const InternalLinker: ({ appCode, defaultAppCode, defaultResourceId, onChange, onSelect, multiple, resourceList, applicationList, showApplicationSelector, }: InternalLinkerProps) => import("react/jsx-runtime").JSX.Element;
+export default InternalLinker;