@measured/puck-plugin-heading-analyzer 0.20.0-canary.f73c8fa0 → 0.20.0

package/dist/index.css

@@ -1,18 +1,162 @@
 /* css-module:/home/runner/work/puck/puck/packages/plugin-heading-analyzer/src/HeadingAnalyzer.module.css/#css-module-data */
-._HeadingAnalyzer_yg0s7_1 {
+._HeadingAnalyzer_116v6_1 {
   display: block;
-  padding: 16px;
 }
-._HeadingAnalyzer-cssWarning_yg0s7_6 {
+._HeadingAnalyzer-cssWarning_116v6_5 {
   display: none !important;
 }
-._HeadingAnalyzerItem_yg0s7_10 {
+._HeadingAnalyzerItem_116v6_9 {
   display: inline;
 }
-._HeadingAnalyzerItem--missing_yg0s7_14 {
+._HeadingAnalyzerItem--missing_116v6_13 {
   color: var(--puck-color-red-04);
 }
 
+/* css-module:/home/runner/work/puck/puck/packages/core/components/SidebarSection/styles.module.css/#css-module-data */
+._SidebarSection_8boj8_1 {
+  display: flex;
+  position: relative;
+  flex-direction: column;
+  color: var(--puck-color-black);
+}
+._SidebarSection_8boj8_1:last-of-type {
+  flex-grow: 1;
+}
+._SidebarSection-title_8boj8_12 {
+  background: var(--puck-color-white);
+  padding: 16px;
+  border-bottom: 1px solid var(--puck-color-grey-09);
+  border-top: 1px solid var(--puck-color-grey-09);
+  overflow-x: auto;
+}
+._SidebarSection--noBorderTop_8boj8_20 > ._SidebarSection-title_8boj8_12 {
+  border-top: 0px;
+}
+._SidebarSection-content_8boj8_24 {
+  padding: 16px;
+}
+._SidebarSection--noPadding_8boj8_28 > ._SidebarSection-content_8boj8_24 {
+  padding: 0px;
+}
+._SidebarSection--noPadding_8boj8_28 > ._SidebarSection-content_8boj8_24:last-child {
+  padding-bottom: 4px;
+}
+._SidebarSection_8boj8_1:last-of-type ._SidebarSection-content_8boj8_24 {
+  border-bottom: none;
+  flex-grow: 1;
+}
+._SidebarSection-breadcrumbLabel_8boj8_41 {
+  background: none;
+  border: 0;
+  border-radius: 2px;
+  color: var(--puck-color-azure-04);
+  cursor: pointer;
+  font: inherit;
+  flex-shrink: 0;
+  padding: 0;
+  transition: color 50ms ease-in;
+}
+._SidebarSection-breadcrumbLabel_8boj8_41:focus-visible {
+  outline: 2px solid var(--puck-color-azure-05);
+  outline-offset: 2px;
+}
+@media (hover: hover) and (pointer: fine) {
+  ._SidebarSection-breadcrumbLabel_8boj8_41:hover {
+    color: var(--puck-color-azure-03);
+    transition: none;
+  }
+}
+._SidebarSection-breadcrumbLabel_8boj8_41:active {
+  color: var(--puck-color-azure-02);
+  transition: none;
+}
+._SidebarSection-breadcrumbs_8boj8_70 {
+  align-items: center;
+  display: flex;
+  gap: 4px;
+}
+._SidebarSection-breadcrumb_8boj8_41 {
+  align-items: center;
+  display: flex;
+  gap: 4px;
+}
+._SidebarSection-heading_8boj8_82 {
+  padding-inline-end: 16px;
+}
+._SidebarSection-loadingOverlay_8boj8_86 {
+  background: var(--puck-color-white);
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  height: 100%;
+  width: 100%;
+  top: 0;
+  position: absolute;
+  z-index: 1;
+  pointer-events: all;
+  box-sizing: border-box;
+  opacity: 0.8;
+}
+
+/* css-module:/home/runner/work/puck/puck/packages/core/components/Heading/styles.module.css/#css-module-data */
+._Heading_qxrry_1 {
+  display: block;
+  color: var(--puck-color-black);
+  font-weight: 700;
+  margin: 0;
+}
+._Heading_qxrry_1 b {
+  font-weight: 700;
+}
+._Heading--xxxxl_qxrry_12 {
+  font-size: var(--puck-font-size-xxxxl);
+  letter-spacing: 0.08ch;
+  font-weight: 800;
+}
+._Heading--xxxl_qxrry_18 {
+  font-size: var(--puck-font-size-xxxl);
+}
+._Heading--xxl_qxrry_22 {
+  font-size: var(--puck-font-size-xxl);
+}
+._Heading--xl_qxrry_26 {
+  font-size: var(--puck-font-size-xl);
+}
+._Heading--l_qxrry_30 {
+  font-size: var(--puck-font-size-l);
+}
+._Heading--m_qxrry_34 {
+  font-size: var(--puck-font-size-m);
+}
+._Heading--s_qxrry_38 {
+  font-size: var(--puck-font-size-s);
+}
+._Heading--xs_qxrry_42 {
+  font-size: var(--puck-font-size-xs);
+}
+
+/* css-module:/home/runner/work/puck/puck/packages/core/components/Loader/styles.module.css/#css-module-data */
+@keyframes _loader-animation_nacdm_1 {
+  0% {
+    transform: rotate(0deg) scale(1);
+  }
+  50% {
+    transform: rotate(180deg) scale(0.8);
+  }
+  100% {
+    transform: rotate(360deg) scale(1);
+  }
+}
+._Loader_nacdm_13 {
+  background: transparent;
+  border-radius: 100%;
+  border: 2px solid currentColor;
+  border-bottom-color: transparent;
+  display: inline-block;
+  animation: _loader-animation_nacdm_1 1s 0s infinite linear;
+  animation-fill-mode: both;
+}
+
 /* css-module:/home/runner/work/puck/puck/packages/core/components/OutlineList/styles.module.css/#css-module-data */
 ._OutlineList_w4lzv_1 {
   color: var(--puck-color-grey-03);

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { ReactElement, ReactNode } from 'react';
+import { ReactElement, CSSProperties, ReactNode, JSX } from 'react';
 
 type ItemSelector = {
     index: number;
@@ -41,26 +41,30 @@ type RadioField = BaseField & {
     type: "radio";
     options: FieldOptions;
 };
-type ArrayField<Props extends any = {
+type ArrayField<Props extends {
     [key: string]: any;
-}> = Props extends {
+}[] = {
     [key: string]: any;
-} ? BaseField & {
+}[], UserField extends {} = {}> = BaseField & {
     type: "array";
     arrayFields: {
-        [SubPropName in keyof Props[0]]: Field<Props[0][SubPropName]>;
+        [SubPropName in keyof Props[0]]: UserField extends {
+            type: PropertyKey;
+        } ? Field<Props[0][SubPropName], UserField> | UserField : Field<Props[0][SubPropName], UserField>;
     };
     defaultItemProps?: Props[0];
     getItemSummary?: (item: Props[0], index?: number) => string;
     max?: number;
     min?: number;
-} : never;
+};
 type ObjectField<Props extends any = {
     [key: string]: any;
-}> = BaseField & {
+}, UserField extends {} = {}> = BaseField & {
     type: "object";
     objectFields: {
-        [SubPropName in keyof Props]: Field<Props[SubPropName]>;
+        [SubPropName in keyof Props]: UserField extends {
+            type: PropertyKey;
+        } ? Field<Props[SubPropName]> | UserField : Field<Props[SubPropName]>;
     };
 };
 type Adaptor<AdaptorParams = {}, TableShape extends Record<string, any> = {}, PropShape = TableShape> = {
@@ -116,7 +120,14 @@ type SlotField = BaseField & {
     allow?: string[];
     disallow?: string[];
 };
-type Field<ValueType = any> = TextField | NumberField | TextareaField | SelectField | RadioField | ArrayField<ValueType> | ObjectField<ValueType> | ExternalField<ValueType> | ExternalFieldWithAdaptor<ValueType> | CustomField<ValueType> | SlotField;
+type Field<ValueType = any, UserField extends {} = {}> = TextField | NumberField | TextareaField | SelectField | RadioField | ArrayField<ValueType extends {
+    [key: string]: any;
+}[] ? ValueType : {}[], UserField> | ObjectField<ValueType, UserField> | ExternalField<ValueType> | ExternalFieldWithAdaptor<ValueType> | CustomField<ValueType> | SlotField;
+type Fields<ComponentProps extends DefaultComponentProps = DefaultComponentProps, UserField extends {} = {}> = {
+    [PropName in keyof Omit<ComponentProps, "editMode">]: UserField extends {
+        type: PropertyKey;
+    } ? Field<ComponentProps[PropName], UserField> | UserField : Field<ComponentProps[PropName]>;
+};
 type FieldProps<F = Field<any>, ValueType = any> = {
     field: F;
     value: ValueType;
@@ -125,10 +136,164 @@ type FieldProps<F = Field<any>, ValueType = any> = {
     readOnly?: boolean;
 };
 
-type ExtractField<T extends Field["type"]> = Extract<Field, {
+type DropZoneProps = {
+    zone: string;
+    allow?: string[];
+    disallow?: string[];
+    style?: CSSProperties;
+    minEmptyHeight?: number;
+    className?: string;
+    collisionAxis?: DragAxis;
+};
+
+type PuckContext = {
+    renderDropZone: React.FC<DropZoneProps>;
+    metadata: Metadata;
+    isEditing: boolean;
+    dragRef: ((element: Element | null) => void) | null;
+};
+type DefaultRootFieldProps = {
+    title?: string;
+};
+type DefaultComponentProps = {
+    [key: string]: any;
+};
+
+type WithId<Props> = Props & {
+    id: string;
+};
+type WithPuckProps<Props> = Props & {
+    puck: PuckContext;
+    editMode?: boolean;
+};
+type AsFieldProps<Props> = Omit<Props, "children" | "puck" | "editMode">;
+type WithChildren<Props> = Props & {
+    children: ReactNode;
+};
+type UserGenerics<UserConfig extends Config = Config, UserParams extends ExtractConfigParams<UserConfig> = ExtractConfigParams<UserConfig>, UserData extends Data<UserParams["props"], UserParams["rootProps"]> | Data = Data<UserParams["props"], UserParams["rootProps"]>, UserAppState extends PrivateAppState<UserData> = PrivateAppState<UserData>, UserPublicAppState extends AppState<UserData> = AppState<UserData>, UserComponentData extends ComponentData = UserData["content"][0]> = {
+    UserConfig: UserConfig;
+    UserParams: UserParams;
+    UserProps: UserParams["props"];
+    UserRootProps: UserParams["rootProps"] & DefaultRootFieldProps;
+    UserData: UserData;
+    UserAppState: UserAppState;
+    UserPublicAppState: UserPublicAppState;
+    UserComponentData: UserComponentData;
+    UserField: UserParams["field"];
+};
+type ExtractField<UserField extends {
+    type: PropertyKey;
+}, T extends UserField["type"]> = Extract<UserField, {
     type: T;
 }>;
 
+type SlotComponent = (props?: Omit<DropZoneProps, "zone">) => ReactNode;
+type PuckComponent<Props> = (props: WithId<WithPuckProps<{
+    [K in keyof Props]: WithDeepSlots<Props[K], SlotComponent>;
+}>>) => JSX.Element;
+type ResolveDataTrigger = "insert" | "replace" | "load" | "force";
+type WithPartialProps<T, Props extends DefaultComponentProps> = Omit<T, "props"> & {
+    props?: Partial<Props>;
+};
+type ComponentConfigInternal<RenderProps extends DefaultComponentProps, FieldProps extends DefaultComponentProps, DataShape = Omit<ComponentData<FieldProps>, "type">, // NB this doesn't include AllProps, so types will not contain deep slot types. To fix, we require a breaking change.
+UserField extends BaseField = {}> = {
+    render: PuckComponent<RenderProps>;
+    label?: string;
+    defaultProps?: FieldProps;
+    fields?: Fields<FieldProps, UserField>;
+    permissions?: Partial<Permissions>;
+    inline?: boolean;
+    resolveFields?: (data: DataShape, params: {
+        changed: Partial<Record<keyof FieldProps, boolean> & {
+            id: string;
+        }>;
+        fields: Fields<FieldProps>;
+        lastFields: Fields<FieldProps>;
+        lastData: DataShape | null;
+        appState: AppState;
+        parent: ComponentData | null;
+    }) => Promise<Fields<FieldProps>> | Fields<FieldProps>;
+    resolveData?: (data: DataShape, params: {
+        changed: Partial<Record<keyof FieldProps, boolean> & {
+            id: string;
+        }>;
+        lastData: DataShape | null;
+        metadata: Metadata;
+        trigger: ResolveDataTrigger;
+    }) => Promise<WithPartialProps<DataShape, FieldProps>> | WithPartialProps<DataShape, FieldProps>;
+    resolvePermissions?: (data: DataShape, params: {
+        changed: Partial<Record<keyof FieldProps, boolean> & {
+            id: string;
+        }>;
+        lastPermissions: Partial<Permissions>;
+        permissions: Partial<Permissions>;
+        appState: AppState;
+        lastData: DataShape | null;
+    }) => Promise<Partial<Permissions>> | Partial<Permissions>;
+    metadata?: Metadata;
+};
+type RootConfigInternal<RootProps extends DefaultComponentProps = DefaultComponentProps, UserField extends BaseField = {}> = Partial<ComponentConfigInternal<WithChildren<RootProps>, AsFieldProps<RootProps>, RootData<AsFieldProps<RootProps>>, UserField>>;
+type Category<ComponentName> = {
+    components?: ComponentName[];
+    title?: string;
+    visible?: boolean;
+    defaultExpanded?: boolean;
+};
+type ConfigInternal<Props extends DefaultComponents = DefaultComponents, RootProps extends DefaultComponentProps = DefaultComponentProps, CategoryName extends string = string, UserField extends {} = {}> = {
+    categories?: Record<CategoryName, Category<keyof Props>> & {
+        other?: Category<keyof Props>;
+    };
+    components: {
+        [ComponentName in keyof Props]: Omit<ComponentConfigInternal<Props[ComponentName], Props[ComponentName], Omit<ComponentData<Props[ComponentName]>, "type">, UserField>, "type">;
+    };
+    root?: RootConfigInternal<RootProps, UserField>;
+};
+type DefaultComponents = Record<string, any>;
+type Config<PropsOrParams extends LeftOrExactRight<PropsOrParams, DefaultComponents, ConfigParams> = DefaultComponents | ConfigParams, RootProps extends DefaultComponentProps = DefaultComponentProps, CategoryName extends string = string> = PropsOrParams extends ConfigParams<infer ParamComponents, infer ParamRoot, infer ParamCategoryName, never> ? ConfigInternal<ParamComponents, ParamRoot, ParamCategoryName[number]> : PropsOrParams extends ConfigParams<infer ParamComponents, infer ParamRoot, infer ParamCategoryName, infer ParamFields> ? ConfigInternal<ParamComponents, ParamRoot, ParamCategoryName[number], ParamFields[keyof ParamFields] & BaseField> : PropsOrParams extends ConfigParams<infer ParamComponents, infer ParamRoot, infer ParamCategoryName, any> ? ConfigInternal<ParamComponents, ParamRoot, ParamCategoryName[number], {}> : ConfigInternal<PropsOrParams, RootProps, CategoryName>;
+type ExtractConfigParams<UserConfig extends ConfigInternal> = UserConfig extends ConfigInternal<infer PropsOrParams, infer RootProps, infer CategoryName, infer UserField> ? {
+    props: PropsOrParams;
+    rootProps: RootProps & DefaultRootFieldProps;
+    categoryNames: CategoryName;
+    field: UserField extends {
+        type: string;
+    } ? UserField : Field;
+} : never;
+
+type BaseData<Props extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}> = {
+    readOnly?: Partial<Record<keyof Props, boolean>>;
+};
+type RootDataWithProps<Props extends DefaultComponentProps = DefaultRootFieldProps> = BaseData<Props> & {
+    props: Props;
+};
+type RootDataWithoutProps<Props extends DefaultComponentProps = DefaultRootFieldProps> = Props;
+type RootData<Props extends DefaultComponentProps = DefaultRootFieldProps> = Partial<RootDataWithProps<AsFieldProps<Props>>> & Partial<RootDataWithoutProps<Props>>;
+type ComponentData<Props extends DefaultComponentProps = DefaultComponentProps, Name = string, Components extends Record<string, DefaultComponentProps> = Record<string, DefaultComponentProps>> = {
+    type: Name;
+    props: WithDeepSlots<WithId<Props>, Content<Components>>;
+} & BaseData<Props>;
+type ComponentDataOptionalId<Props extends DefaultComponentProps = DefaultComponentProps, Name = string> = {
+    type: Name;
+    props: Props & {
+        id?: string;
+    };
+} & BaseData<Props>;
+type ComponentDataMap<Components extends DefaultComponents = DefaultComponents> = {
+    [K in keyof Components]: ComponentData<Components[K], K extends string ? K : never, Components>;
+}[keyof Components];
+type Content<PropsMap extends {
+    [key: string]: DefaultComponentProps;
+} = {
+    [key: string]: DefaultComponentProps;
+}> = ComponentDataMap<PropsMap>[];
+type Data<Components extends DefaultComponents = DefaultComponents, RootProps extends DefaultComponentProps = DefaultRootFieldProps> = {
+    root: WithDeepSlots<RootData<RootProps>, Content<Components>>;
+    content: Content<Components>;
+    zones?: Record<string, Content<Components>>;
+};
 type Metadata = {
     [key: string]: any;
 };
@@ -136,7 +301,6 @@ type Metadata = {
 type ItemWithId = {
     _arrayId: string;
     _originalIndex: number;
-    _currentIndex: number;
 };
 type ArrayState = {
     items: ItemWithId[];
@@ -168,16 +332,55 @@ type UiState = {
     field: {
         focus?: string | null;
     };
-    plugin: {
-        current: string | null;
-    };
+};
+type AppState<UserData extends Data = Data> = {
+    data: UserData;
+    ui: UiState;
 };
 
-type RenderFunc<Props extends {
-    [key: string]: any;
-} = {
-    children: ReactNode;
-}> = (props: Props) => ReactElement;
+type ZoneType = "root" | "dropzone" | "slot";
+type PuckNodeData = {
+    data: ComponentData;
+    flatData: ComponentData;
+    parentId: string | null;
+    zone: string;
+    path: string[];
+};
+type PuckZoneData = {
+    contentIds: string[];
+    type: ZoneType;
+};
+type NodeIndex = Record<string, PuckNodeData>;
+type ZoneIndex = Record<string, PuckZoneData>;
+type PrivateAppState<UserData extends Data = Data> = AppState<UserData> & {
+    indexes: {
+        nodes: NodeIndex;
+        zones: ZoneIndex;
+    };
+};
+type BuiltinTypes = Date | RegExp | Error | Function | symbol | null | undefined;
+/**
+ * Recursively walk T and replace Slots with SlotComponents
+ */
+type WithDeepSlots<T, SlotType = T> = T extends Slot ? SlotType : T extends (infer U)[] ? Array<WithDeepSlots<U, SlotType>> : T extends (infer U)[] ? WithDeepSlots<U, SlotType>[] : T extends BuiltinTypes ? T : T extends object ? {
+    [K in keyof T]: WithDeepSlots<T[K], SlotType>;
+} : T;
+type ConfigParams<Components extends DefaultComponents = DefaultComponents, RootProps extends DefaultComponentProps = DefaultComponentProps, CategoryNames extends string[] = string[], UserFields extends FieldsExtension = FieldsExtension> = {
+    components?: Components;
+    root?: RootProps;
+    categories?: CategoryNames;
+    fields?: AssertHasValue<UserFields>;
+};
+type FieldsExtension = {
+    [Type in string]: {
+        type: Type;
+    };
+};
+type Exact<T, Target> = Record<Exclude<keyof T, keyof Target>, never>;
+type LeftOrExactRight<Union, Left, Right> = (Left & Union extends Right ? Exact<Union, Right> : Left) | (Right & Exact<Union, Right>);
+type AssertHasValue<T, True = T, False = never> = [keyof T] extends [
+    never
+] ? False : True;
 
 type MapFnParams<ThisField = Field> = {
     value: any;
@@ -191,18 +394,28 @@ type FieldTransformFnParams<T> = Omit<MapFnParams<T>, "parentId"> & {
     isReadOnly: boolean;
     componentId: string;
 };
-type FieldTransformFn<T = any> = (params: FieldTransformFnParams<T>) => any;
-type FieldTransforms = Partial<{
-    [FieldType in Field["type"]]: FieldTransformFn<ExtractField<FieldType>>;
+type FieldTransformFn<T> = (params: FieldTransformFnParams<T>) => any;
+type FieldTransforms<UserConfig extends Config = Config<{
+    fields: {};
+}>, // Setting fields: {} helps TS choose default field types
+G extends UserGenerics<UserConfig> = UserGenerics<UserConfig>, UserField extends {
+    type: string;
+} = Field | G["UserField"]> = Partial<{
+    [Type in UserField["type"]]: FieldTransformFn<ExtractField<UserField, Type>>;
 }>;
 
+type RenderFunc<Props extends {
+    [key: string]: any;
+} = {
+    children: ReactNode;
+}> = (props: Props) => ReactElement;
 declare const overrideKeys: readonly ["header", "headerActions", "fields", "fieldLabel", "drawer", "drawerItem", "componentOverlay", "outline", "puck", "preview"];
 type OverrideKey = (typeof overrideKeys)[number];
 type OverridesGeneric<Shape extends {
     [key in OverrideKey]: any;
 }> = Shape;
-type Overrides = OverridesGeneric<{
-    fieldTypes: Partial<FieldRenderFunctions>;
+type Overrides<UserConfig extends Config = Config> = OverridesGeneric<{
+    fieldTypes: Partial<FieldRenderFunctions<UserConfig>>;
     header: RenderFunc<{
         actions: ReactNode;
         children: ReactNode;
@@ -253,19 +466,16 @@ type Overrides = OverridesGeneric<{
     }>;
     puck: RenderFunc;
 }>;
-type FieldRenderFunctions = Omit<{
-    [Type in Field["type"]]: React.FunctionComponent<FieldProps<Extract<Field, {
-        type: Type;
-    }>, any> & {
-        children: ReactNode;
-        name: string;
-    }>;
-}, "custom"> & {
-    [key: string]: React.FunctionComponent<FieldProps<any> & {
+type FieldRenderFunctions<UserConfig extends Config = Config, G extends UserGenerics<UserConfig> = UserGenerics<UserConfig>, UserField extends {
+    type: string;
+} = Field | G["UserField"]> = Omit<{
+    [Type in UserField["type"]]: React.FunctionComponent<FieldProps<ExtractField<UserField, Type>, any> & {
         children: ReactNode;
         name: string;
     }>;
-};
+}, "custom">;
+
+type DragAxis = "dynamic" | "y" | "x";
 
 type iconTypes = "Smartphone" | "Monitor" | "Tablet";
 type Viewport = {
@@ -275,14 +485,24 @@ type Viewport = {
     icon?: iconTypes | ReactNode;
 };
 
-type Plugin = {
-    name?: string;
-    label?: string;
-    icon?: ReactNode;
-    render?: () => ReactElement;
-    overrides?: Partial<Overrides>;
-    fieldTransforms?: FieldTransforms;
+type Permissions = {
+    drag: boolean;
+    duplicate: boolean;
+    delete: boolean;
+    edit: boolean;
+    insert: boolean;
+} & Record<string, boolean>;
+type Plugin<UserConfig extends Config = Config> = {
+    overrides?: Partial<Overrides<UserConfig>>;
+    fieldTransforms?: FieldTransforms<UserConfig>;
 };
+type Slot<Props extends {
+    [key: string]: DefaultComponentProps;
+} = {
+    [key: string]: DefaultComponentProps;
+}> = {
+    [K in keyof Props]: ComponentDataOptionalId<Props[K], K extends string ? K : never>;
+}[keyof Props][];
 
 declare const headingAnalyzer: Plugin;