@fluid-app/rep-core 0.1.0

package/dist/shareable-item-DPmNZkE1.d.ts

@@ -0,0 +1,138 @@
+import { ComponentType } from 'react';
+
+/**
+ * Widget type names as a const object.
+ * This serves as the single source of truth for widget discriminants.
+ * Use `as const` for literal type inference (safety-as-const-deep-readonly rule).
+ */
+declare const WIDGET_TYPE_NAMES: {
+    readonly Alert: "AlertWidget";
+    readonly Calendar: "CalendarWidget";
+    readonly Carousel: "CarouselWidget";
+    readonly CatchUp: "CatchUpWidget";
+    readonly Chart: "ChartWidget";
+    readonly Container: "ContainerWidget";
+    readonly Embed: "EmbedWidget";
+    readonly Image: "ImageWidget";
+    readonly Layout: "LayoutWidget";
+    readonly List: "ListWidget";
+    readonly MySite: "MySiteWidget";
+    readonly Nested: "NestedWidget";
+    readonly QuickShare: "QuickShareWidget";
+    readonly RecentActivity: "RecentActivityWidget";
+    readonly Spacer: "SpacerWidget";
+    readonly Table: "TableWidget";
+    readonly Text: "TextWidget";
+    readonly ToDo: "ToDoWidget";
+    readonly Video: "VideoWidget";
+};
+/**
+ * Union of all known widget type names.
+ * Derived from WIDGET_TYPE_NAMES to avoid duplication (deriving-typeof-for-object-keys rule).
+ */
+type WidgetTypeName = (typeof WIDGET_TYPE_NAMES)[keyof typeof WIDGET_TYPE_NAMES];
+/**
+ * Legacy alias for backwards compatibility.
+ * Prefer using WidgetTypeName for new code when you need the union type.
+ */
+type WidgetType = string;
+type WidgetRegistry = Record<WidgetType, ComponentType<any>>;
+/**
+ * Base widget schema with loose typing for runtime data.
+ * Use TypedWidgetSchema<T> when you have a known registry for better type safety.
+ */
+type WidgetSchema = {
+    readonly type: WidgetType;
+    readonly props: Readonly<Record<string, unknown>>;
+    readonly id?: string;
+    /** Column index for masonry layouts (0-indexed) */
+    readonly columnIndex?: number;
+};
+/**
+ * Type-safe widget schema based on registry.
+ * Uses discriminated unions - the `type` field serves as discriminant.
+ * When narrowed (e.g., `if (widget.type === "AlertWidget")`),
+ * TypeScript automatically knows the correct props type.
+ */
+type TypedWidgetSchema<T extends Record<string, ComponentType<any>>> = {
+    [K in keyof T]: {
+        readonly type: K;
+        readonly props: Readonly<React.ComponentProps<T[K]>>;
+        readonly id?: string;
+        /** Column index for masonry layouts (0-indexed) */
+        readonly columnIndex?: number;
+    };
+}[keyof T];
+/**
+ * Widget path in the tree - array of indices.
+ * Readonly tuple to prevent accidental mutation.
+ */
+type WidgetPath = readonly number[];
+/**
+ * Type predicate to check if a string is a known widget type name.
+ * Use for runtime validation of widget types.
+ *
+ * @example
+ * if (isWidgetTypeName(widget.type)) {
+ *   // TypeScript knows widget.type is WidgetTypeName
+ * }
+ */
+declare function isWidgetTypeName(type: string): type is WidgetTypeName;
+/**
+ * Type predicate to check if a widget has a specific type.
+ * Enables type-safe widget narrowing without `as` assertions.
+ *
+ * @example
+ * if (isWidgetType(widget, "LayoutWidget")) {
+ *   // TypeScript knows widget.type === "LayoutWidget"
+ *   // and widget.props is LayoutWidget props
+ * }
+ */
+declare function isWidgetType<T extends WidgetTypeName>(widget: WidgetSchema | null | undefined, typeName: T): widget is WidgetSchema & {
+    readonly type: T;
+};
+/**
+ * Helper for exhaustive switch statements on widget types.
+ * Use in the default case to ensure all widget types are handled.
+ *
+ * @example
+ * switch (widget.type) {
+ *   case "AlertWidget": return handleAlert();
+ *   case "TextWidget": return handleText();
+ *   // ... all other widget types
+ *   default: return assertNever(widget.type, "widget type");
+ * }
+ */
+declare function assertNever(value: never, context?: string): never;
+/**
+ * Assertion function that throws if value is undefined.
+ * Narrows the type to exclude undefined.
+ *
+ * @example
+ * const widget = screen[0];
+ * assertDefined(widget, "widget at index 0");
+ * // TypeScript knows widget is defined here
+ */
+declare function assertDefined<T>(value: T | undefined | null, name?: string): asserts value is T;
+
+/**
+ * Base props for a shareable item.
+ * Uses structural typing to be compatible with various modal implementations.
+ * The index signature allows additional properties from consuming apps.
+ */
+interface ShareableItem {
+    id: string | number;
+    title?: string | null;
+    image_url?: string | null;
+    imageUrl?: string | null;
+    kind?: string | null;
+    type?: string | null;
+    shareableType?: string | null;
+    share_link?: string | null;
+    videoUrl?: string;
+    price?: string | number | null;
+    display_price?: string | null;
+    [key: string]: unknown;
+}
+
+export { type ShareableItem as S, type TypedWidgetSchema as T, type WidgetPath as W, type WidgetSchema as a, type WidgetType as b, type WidgetTypeName as c, type WidgetRegistry as d, WIDGET_TYPE_NAMES as e, isWidgetType as f, assertNever as g, assertDefined as h, isWidgetTypeName as i };