@hanzo/ui 4.5.0 → 4.5.3

package/dist/blocks/components/cta-block.jsx

@@ -0,0 +1,69 @@
+import React from 'react';
+import { buttonVariants, ActionButton, LinkElement } from '../../primitives/index-next';
+import { cn, containsToken } from '../../util';
+const CtaBlockComponent = ({ block, className = '', // assigned to each item
+itemClasses = '', itemSize, // do not provide default.  this is an override to the def
+renderLink, renderButton, agent }) => {
+    if (block.blockType !== 'cta') {
+        return <>cta block required</>;
+    }
+    const { elements, specifiers } = block;
+    let wrapperClasses = '';
+    let itemclx = '';
+    if (containsToken(specifiers, 'fill')) {
+        wrapperClasses += 'w-full ';
+        itemclx += 'grow shrink !min-w-0';
+    }
+    else if (containsToken(specifiers, 'left')) {
+        wrapperClasses += 'md:justify-start ';
+    }
+    else if (containsToken(specifiers, 'right')) {
+        wrapperClasses += 'md:justify-end ';
+    }
+    else {
+        wrapperClasses += 'md:justify-center ';
+    }
+    const mobile2Columns = containsToken(specifiers, 'mobile-2-columns');
+    // normally 'default' buttons have a min width only at > lg.
+    // generally if more than one we don't want this and override it,
+    // but this specifier asks to observe the default behavior.
+    const fillEvenly = !containsToken(specifiers, 'desktop-dont-fill');
+    const mobileCenterFirstIfOdd = containsToken(specifiers, 'mobile-center-first-if-odd');
+    const mobileOddFullWidth = containsToken(specifiers, 'mobile-odd-full-width');
+    let layoutclx = undefined;
+    if (elements.length > 1) {
+        let resetMinWidth = false;
+        if (mobile2Columns) {
+            layoutclx = 'grid grid-cols-2 gap-2 self-stretch ';
+            resetMinWidth = true;
+        }
+        if (fillEvenly) {
+            layoutclx = (layoutclx ?? 'grid grid-cols-2 gap-2 self-stretch');
+            resetMinWidth = true;
+        }
+        else {
+            layoutclx = layoutclx ? (layoutclx + 'md:flex md:flex-row md:justify-center ') : 'flex flex-row justify-center ';
+        }
+        itemclx += resetMinWidth ? '!min-w-0 ' : '';
+    }
+    layoutclx = layoutclx ?? 'flex flex-col items-stretch gap-2 self-stretch md:flex-row sm:justify-center ';
+    const getMobileColSpanClx = (index, total) => {
+        const indexToCenter = (total % 2 === 0) ? -1 : (mobileCenterFirstIfOdd) ? 0 : total - 1;
+        const widthclx = mobileOddFullWidth ? 'w-full ' : 'w-3/5 mx-auto ';
+        return ((agent === 'phone' && mobile2Columns && (index === indexToCenter)) ? ('col-span-2 ' + widthclx) : '');
+    };
+    return (<div className={cn(layoutclx, wrapperClasses, className)}>
+    {elements.map((element, index) => {
+            const twoColClx = getMobileColSpanClx(index, elements.length);
+            if (element.title) {
+                const def = element;
+                return renderLink ? renderLink(def, index) : (<LinkElement def={def} key={index} size={itemSize} className={cn(itemclx, itemClasses, twoColClx)}/>);
+            }
+            else {
+                const def = element;
+                return renderButton ? renderButton(def, index) : (<ActionButton def={def} key={index} size={itemSize} className={cn(itemclx, itemClasses, twoColClx)}/>);
+            }
+        })}
+    </div>);
+};
+export default CtaBlockComponent;

package/dist/blocks/components/enh-heading-block.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type BlockComponentProps from './block-component-props';
+declare const EnhHeadingBlockComponent: React.FC<BlockComponentProps & {
+    applyTypography?: boolean;
+    extraSpecifiers?: string;
+}>;
+export default EnhHeadingBlockComponent;

package/dist/blocks/components/enh-heading-block.jsx

@@ -0,0 +1,142 @@
+import React, {} from 'react';
+import { ApplyTypography } from '../../primitives/index-common';
+import { cn, containsToken } from '../../util';
+import InlineIcon from '../../primitives/next/inline-icon';
+const DEFAULTS = {
+    preheading: {
+        tag: 'h4',
+        mb: 2
+    },
+    heading: {
+        tag: 'h1',
+        mb: 2
+    },
+    byline: {
+        tag: 'h6',
+    }
+};
+const tagFromLevel = (level) => {
+    switch (level) {
+        case 1: {
+            return 'h1';
+        }
+        case 2: {
+            return 'h2';
+        }
+        case 3: {
+            return 'h3';
+        }
+        case 4: {
+            return 'h4';
+        }
+        case 5: {
+            return 'h5';
+        }
+        case 6: {
+            return 'h6';
+        }
+    }
+    return 'p';
+};
+// TODO Impl icon support
+const Element = ({ asTag: Tag, text, icon, iconLeft = true, className: elClassName = '' }) => (<Tag className={elClassName}>{text}</Tag>);
+const getPositionClx = (specified, agent) => {
+    const mobileHeadingCentered = specified('mobile-heading-centered');
+    const mobileHeadingLeft = specified('mobile-heading-left');
+    const headingCentered = specified('center');
+    const headingRight = specified('right');
+    const bylineCentered = specified('byline-center');
+    const bylineRight = specified('byline-right');
+    const mobileBylineLeft = specified('mobile-byline-left');
+    let headerclx = '';
+    let bylineclx = (bylineCentered) ?
+        'self-center !text-center' : (bylineRight ? 'self-end !text-right' : 'self-start !text-left');
+    if (agent === 'phone') {
+        if (mobileHeadingLeft) {
+            headerclx = 'self-start text-left';
+        }
+        else {
+            headerclx = (mobileHeadingCentered || headingCentered) ?
+                'self-center text-center' : (headingRight ? 'self-end text-right' : 'self-start text-left');
+        }
+        if (mobileBylineLeft) {
+            bylineclx = 'self-start !text-left';
+        }
+    }
+    else {
+        const largerclx = (headingCentered) ?
+            'self-center text-center' : (headingRight ? 'self-end text-right' : 'self-start text-left');
+        if (mobileHeadingCentered) {
+            headerclx = 'self-center text-center md:' + largerclx.split(' ').join(' md:');
+        }
+        else {
+            headerclx = largerclx;
+        }
+    }
+    return {
+        preheading: headerclx,
+        heading: headerclx,
+        byline: bylineclx
+    };
+};
+const EnhHeadingBlockComponent = ({ block, className = '', agent, applyTypography = true, extraSpecifiers = '' }) => {
+    if (block.blockType !== 'enh-heading') {
+        return <>enhance heading block required</>;
+    }
+    const b = block;
+    const specified = (s) => (containsToken(b.specifiers + extraSpecifiers, s));
+    const preheadingHeadingFont = specified('preheading-heading-font');
+    const phFontClx = preheadingHeadingFont ? 'font-heading' : '';
+    const alignMiddleClx = specified('align-middle') ? 'my-auto' : '';
+    const positionclx = getPositionClx(specified, agent);
+    const Inner = () => {
+        const toRender = [
+            {
+                tag: (b.preheading) ?
+                    (b.preheading.level !== undefined ? tagFromLevel(b.preheading.level) : DEFAULTS.preheading.tag)
+                    :
+                        undefined,
+                clx: (b.preheading) ?
+                    (b.preheading.mb !== undefined ?
+                        `mb-${b.preheading.mb}` : `mb-${DEFAULTS.preheading.mb}`) + ' ' + positionclx.preheading + ' ' + phFontClx
+                    :
+                        positionclx.preheading + ' ' + phFontClx,
+                text: (b.preheading) ? (b.preheading.text) : undefined,
+            },
+            {
+                tag: (b.heading.level !== undefined ? tagFromLevel(b.heading.level) : DEFAULTS.heading.tag),
+                clx: (b.heading.mb !== undefined ? `mb-${b.heading.mb}` : `mb-${DEFAULTS.heading.mb}`) + ' ' + positionclx.heading,
+                text: b.heading.text,
+            },
+            {
+                tag: (b.byline) ?
+                    (b.byline.level !== undefined ? tagFromLevel(b.byline.level) : DEFAULTS.byline.tag)
+                    :
+                        undefined,
+                clx: positionclx.byline,
+                text: (b.byline) ? (b.byline.text) : undefined,
+            },
+        ];
+        let iconRendered = false;
+        return <>
+      {toRender.map(({ tag, clx, text }, index) => {
+                if (!tag)
+                    return null;
+                if (b.icon && !iconRendered) {
+                    iconRendered = true;
+                    return (<div className={cn('flex flex-row items-center gap-2 sm:gap-4', clx)} key={`div-${index}`}>
+              <InlineIcon icon={b.icon} size={b.iconSize ?? 32} agent={agent}/>
+              <Element asTag={tag} text={text}/>
+            </div>);
+                }
+                return ((<Element asTag={tag} text={text} className={clx} key={`el-${index}`}/>));
+            })}
+    </>;
+    };
+    return applyTypography ? (<ApplyTypography className={cn('flex flex-col w-full !gap-0', className, alignMiddleClx)}>
+      <Inner />
+    </ApplyTypography>) : (<div className={cn('flex flex-col w-full gap-0', className, alignMiddleClx)}>
+      <Inner />  
+    </div>);
+};
+export default EnhHeadingBlockComponent;

package/dist/blocks/components/grid-block/grid-block-mutator.d.ts

@@ -0,0 +1,5 @@
+interface GridBlockMutator {
+    gapClx?: string;
+    getCellClx?: (cellIndex: number, cellCount: number, colCount: number) => string;
+}
+export { type GridBlockMutator as default };

package/dist/blocks/components/grid-block/grid-block-mutator.js

@@ -0,0 +1 @@
+export {};

package/dist/blocks/components/grid-block/index.d.ts

@@ -0,0 +1,9 @@
+import React, { type PropsWithChildren } from 'react';
+import type BlockComponentProps from '../block-component-props';
+/**
+ * A component that lays out the Blocks in 'cells' on a grid.
+ * If invoked directly, and children are supplied,
+ * block.cells is ignore and the children are rendered.
+ */
+declare const GridBlockComponent: React.FC<BlockComponentProps & PropsWithChildren>;
+export default GridBlockComponent;

package/dist/blocks/components/grid-block/index.jsx

@@ -0,0 +1,56 @@
+import React, {} from 'react';
+import { cn, containsToken } from '../../../util';
+import Content from '../content';
+import getMutator from './mutator-registry';
+// These must be / are safelisted in tailwind.config
+const gridClx = (d, prefix) => ((typeof d === 'number') ?
+    `${(prefix ?? '')}grid-cols-${d} `
+    :
+        `${(prefix ?? '')}grid-cols-${d.columns} ${(prefix ?? '')}gap-${d.gap} `);
+/**
+ * A component that lays out the Blocks in 'cells' on a grid.
+ * If invoked directly, and children are supplied,
+ * block.cells is ignore and the children are rendered.
+ */
+const GridBlockComponent = ({ block, className = '', agent, children }) => {
+    if (block.blockType !== 'grid') {
+        return <>grid block required</>;
+    }
+    const { cells, grid, specifiers } = block;
+    const specified = (s) => (containsToken(specifiers, s));
+    const mutator = specified('style-table-borders') ? getMutator('style-table-borders') : undefined;
+    // https://tailwindcss.com/docs/content-configuration#dynamic-class-names
+    // All variants in use MUST be in style/safelist.tailwind.js
+    let clx = 'grid ';
+    if (agent === 'phone') {
+        const d = (grid.mobile) ? grid.mobile : (grid.at.xs ? grid.at.xs : (grid.at.sm ?? 1));
+        clx += gridClx(d);
+    }
+    else {
+        let defaultSet = false;
+        for (const [key, value] of Object.entries(grid.at)) {
+            if (!defaultSet) {
+                // ts brain fart!
+                clx += gridClx(value);
+                defaultSet = true;
+            }
+            else {
+                // ts brain fart!
+                clx += gridClx(value, `${key}:`);
+            }
+        }
+    }
+    let getMutatorCellClx = (ignore) => ('');
+    if (mutator?.getCellClx) {
+        const colCount = (typeof grid.at.md === 'number') ? grid.at.md : grid.at.md.columns;
+        const cellCount = cells?.length;
+        if (!colCount || !cellCount) {
+            throw new Error('GridBlockComponent: using mutator, but colCount and / or cellCount is invalid!');
+        }
+        getMutatorCellClx = (cellIndex) => (mutator.getCellClx(cellIndex, cellCount, colCount));
+    }
+    return (<div className={cn('grid gap-2 md:gap-4 xl:gap-6', clx, (mutator?.gapClx ?? ''), className)}>
+    {React.Children.count(children) > 0 ? children : cells?.map((cell, index) => (<Content blocks={cell} agent={agent} key={`cell-${index}`} className={getMutatorCellClx(index)}/>))}
+    </div>);
+};
+export default GridBlockComponent;

package/dist/blocks/components/grid-block/mutator-registry.d.ts

@@ -0,0 +1,3 @@
+import type GridBlockMutator from './grid-block-mutator';
+declare const _default: (key: string) => GridBlockMutator | undefined;
+export default _default;

package/dist/blocks/components/grid-block/mutator-registry.js

@@ -0,0 +1,5 @@
+import tableBorders from './table-borders.mutator';
+const map = new Map();
+map.set('style-table-borders', tableBorders);
+// get 
+export default (key) => (map.get(key));

package/dist/blocks/components/grid-block/table-borders.mutator.d.ts

@@ -0,0 +1,3 @@
+import type GridBlockMutator from './grid-block-mutator';
+declare const _default: GridBlockMutator;
+export default _default;

package/dist/blocks/components/grid-block/table-borders.mutator.js

@@ -0,0 +1,36 @@
+const getCellClx = (cellIndex, cellCount, colCount) => {
+    const isFirstRow = () => (cellIndex < colCount);
+    const isFirstColumn = () => (cellIndex % colCount === 0);
+    const isTLCorner = () => (cellIndex === 0);
+    const isTRCorner = () => (cellIndex === colCount - 1);
+    const isBLCorner = () => (cellIndex === cellCount - colCount);
+    const isBRCorner = () => (cellIndex === cellCount - 1);
+    // all get a right and bottom border and padding, 
+    // other borders are a special base
+    let clx = 'border-b md:border-r p-4 md:p-8 lg:p-12 ';
+    if (isFirstRow()) {
+        clx += 'border-t ';
+    }
+    if (isFirstColumn()) {
+        clx += 'md:border-l ';
+    }
+    // on mobile this will be the first (top) cell
+    if (isTLCorner()) {
+        clx += 'border-t md:rounded-tl-lg ';
+    }
+    else if (isTRCorner()) {
+        clx += 'md:rounded-tr-lg ';
+    }
+    else if (isBLCorner()) {
+        clx += 'md:rounded-bl-lg ';
+    }
+    else if (isBRCorner()) {
+        clx += 'md:rounded-br-lg ';
+    }
+    return clx;
+};
+const gapClx = 'gap-0 md:gap-0 xl:gap-0';
+export default {
+    getCellClx,
+    gapClx
+};

package/dist/blocks/components/group-block.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { Block } from '../def';
+declare const GroupBlockComponent: React.FC<{
+    block: Block;
+    className?: string;
+}>;
+export default GroupBlockComponent;

package/dist/blocks/components/group-block.jsx

@@ -0,0 +1,61 @@
+import React from 'react';
+import { Breakpoints } from '../../types';
+import { cn } from '../../util';
+import Content from './content';
+// eg: 'layout-grid-2-starting-md'
+// see comments below regarding dynamic classes and the safelist
+const getLayoutInfo = (s) => {
+    const tokenArray = s.split(' ');
+    const layoutToken = tokenArray.find((tok) => (tok.startsWith('layout-')));
+    if (layoutToken) {
+        const subtokens = layoutToken.split('-');
+        const layout = subtokens[1];
+        let spec = {};
+        switch (layout) {
+            case 'grid':
+                {
+                    const columns = parseInt(subtokens[2], 10);
+                    const starting = subtokens[4];
+                    if (Number.isNaN(columns) || columns < 2 || columns > 6 || !Breakpoints.includes(starting)) {
+                        return undefined;
+                    }
+                    spec = {
+                        columns,
+                        starting
+                    };
+                }
+                break;
+            // no other types supported yet
+        }
+        return {
+            layout,
+            spec
+        };
+    }
+    return undefined;
+};
+const GroupBlockComponent = ({ block, className = '' }) => {
+    if (block.blockType !== 'group') {
+        return <>group block required</>;
+    }
+    const group = block;
+    // only one supported so fat
+    if (group.specifiers?.includes('layout')) {
+        const layoutSpec = getLayoutInfo(group.specifiers);
+        if (!layoutSpec) {
+            return <>invalid or missing layout specifier in group block!</>;
+        }
+        if (layoutSpec.layout === 'grid') {
+            const { elements } = group;
+            const { spec: { starting, columns } } = layoutSpec;
+            // https://tailwindcss.com/docs/content-configuration#dynamic-class-names
+            // All variants in use MUST be in style/safelist.tailwind.js
+            const clazzName = cn('grid xs:grid-cols-1 gap-2 sm:gap-3', `${starting}:grid-cols-${columns} `, className);
+            return (<div className={clazzName}>
+          <Content blocks={elements}/>
+        </div>);
+        }
+    }
+    return null;
+};
+export default GroupBlockComponent;

package/dist/blocks/components/heading-block.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type BlockComponentProps from './block-component-props';
+declare const HeadingBlockComponent: React.FC<BlockComponentProps>;
+export default HeadingBlockComponent;

package/dist/blocks/components/heading-block.jsx

@@ -0,0 +1,99 @@
+import React from 'react';
+import { ApplyTypography } from '../../primitives/index-common';
+const HeadingBlockComponent = ({ block, className = '' }) => {
+    if (block.blockType !== 'heading') {
+        return <>heading block required</>;
+    }
+    const heading = block;
+    let Tag;
+    let BylineTag = undefined;
+    switch (heading.bylineLevel) {
+        case 0:
+            {
+                BylineTag = 'p';
+            }
+            break;
+        case 1:
+            {
+                BylineTag = 'h1';
+            }
+            break;
+        case 2:
+            {
+                BylineTag = 'h2';
+            }
+            break;
+        case 3:
+            {
+                BylineTag = 'h3';
+            }
+            break;
+        case 4:
+            {
+                BylineTag = 'h4';
+            }
+            break;
+        case 5:
+            {
+                BylineTag = 'h5';
+            }
+            break;
+        case 6:
+            {
+                BylineTag = 'h6';
+            }
+            break;
+    }
+    // bylineLevel default is two levels below the main heading
+    switch (heading.level) {
+        case 0:
+            {
+                Tag = 'p';
+                BylineTag = BylineTag ?? 'p';
+            }
+            break;
+        case 1:
+            {
+                Tag = 'h1';
+                BylineTag = BylineTag ?? 'h3';
+            }
+            break;
+        case 2:
+            {
+                Tag = 'h2';
+                BylineTag = BylineTag ?? 'h4';
+            }
+            break;
+        // 3 is default
+        case 4:
+            {
+                Tag = 'h4';
+                BylineTag = BylineTag ?? 'h6';
+            }
+            break;
+        case 5:
+            {
+                Tag = 'h5';
+                BylineTag = BylineTag ?? 'p';
+            }
+            break;
+        case 6:
+            {
+                Tag = 'h6';
+                BylineTag = BylineTag ?? 'p';
+            }
+            break;
+        default: {
+            Tag = 'h3';
+            BylineTag = BylineTag ?? 'h5';
+        }
+    }
+    // Had to do this way, since tw typo plugin does support overrding typo styling wiithout .not-typography
+    return (<ApplyTypography className={className}>
+      <Tag>{heading.heading}</Tag>
+      {heading.spaceBetween && <div className={'w-[1px] ' + `h-${heading.spaceBetween}`}/>}
+      {heading.byline && (<BylineTag>{heading.byline}</BylineTag>)}
+      {heading.spaceAfter && <div className={'w-[1px] ' + `h-${heading.spaceAfter}`}/>}
+    </ApplyTypography>);
+};
+export default HeadingBlockComponent;

package/dist/blocks/components/image-block.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { Dimensions } from '../../types';
+import type BlockComponentProps from './block-component-props';
+declare const ImageBlockComponent: React.FC<BlockComponentProps & {
+    constraintTo?: Dimensions;
+}>;
+export default ImageBlockComponent;

package/dist/blocks/components/image-block.jsx

@@ -0,0 +1,69 @@
+import React from 'react';
+import Image from 'next/image';
+import { constrain, containsToken, cn } from '../../util';
+const ImageBlockComponent = ({ block, className = '', agent, constraintTo }) => {
+    if (block.blockType !== 'image') {
+        return <>image block required</>;
+    }
+    const { src, alt, dim, props, sizes, fullWidthOnMobile, svgFillClass, specifiers } = block;
+    const specified = (s) => (containsToken(specifiers, s));
+    const toSpread = {};
+    if (props?.fill === undefined) {
+        const resolved = constraintTo ? constrain(dim, constraintTo) : dim;
+        toSpread.width = resolved.w;
+        toSpread.height = resolved.h;
+    }
+    let _alt;
+    if (alt) {
+        _alt = alt;
+    }
+    else {
+        const tokens = src.split('/');
+        // Something remotely meaningful
+        _alt = (tokens.length > 0) ? tokens[tokens.length] : src;
+    }
+    const _svgFillClass = svgFillClass ?? '';
+    // TODO: use two elements with 'md:hidden' for 3/4 size
+    // https://nextjs.org/docs/app/building-your-application/optimizing/images#responsive
+    if (agent === 'phone') {
+        if (specified('mobile-full-width') || fullWidthOnMobile) {
+            const toSpread = {
+                style: {
+                    width: '100%',
+                    height: 'auto',
+                    maxWidth: '420px'
+                },
+                sizes: '100vw',
+            };
+            // only for aspect ratio and to satisfy parser
+            toSpread.width = dim.w;
+            toSpread.height = dim.h;
+            return (<div className='flex flex-col items-center w-full'>
+          <Image src={src} alt={_alt} {...toSpread} className={cn(_svgFillClass, className)}/>
+        </div>);
+        }
+        // TODO use constraint
+        else if (!specified('mobile-no-scale')) {
+            if (props?.style?.width === 'auto' && typeof props.style.height === 'number') {
+                props.style.height = props.style.height * .75;
+            }
+            else if (props?.style?.height === 'auto' && typeof props?.style?.width === 'number') {
+                props.style.width = props.style.width * .75;
+            }
+            else if (props?.style && !props?.style.width) {
+                toSpread.width = dim.w * .75;
+                toSpread.height = dim.h * .75;
+            }
+        }
+    }
+    if (sizes) {
+        toSpread.sizes = sizes;
+    }
+    const right = containsToken(specifiers, 'right');
+    const center = containsToken(specifiers, 'center');
+    const alignSelfClx = right ? 'self-end' : (center ? 'self-center' : 'self-start');
+    return (props?.fill) ? (<div className='relative w-full h-full'>
+      <Image src={src} alt={_alt} {...toSpread} {...props} className={cn(_svgFillClass, 'max-w-[70vw] mx-auto', className)}/>
+    </div>) : (<Image src={src} alt={_alt} {...toSpread} {...props} className={cn(alignSelfClx, _svgFillClass, 'max-w-[70vw] mx-auto', className)}/>);
+};
+export default ImageBlockComponent;

package/dist/blocks/components/index.d.ts

@@ -0,0 +1,14 @@
+import AccordianBlock from './accordian-block';
+import type BlockComponentProps from './block-component-props';
+import Blocks from './content';
+import CardBlock from './card-block';
+import { default as ContentComponent, registerBlockType } from './content';
+import CTABlock from './cta-block';
+import EnhHeadingBlock from './enh-heading-block';
+import GroupBlock from './group-block';
+import HeadingBlock from './heading-block';
+import ImageBlock from './image-block';
+import SpaceBlock from './space-block';
+import ScreenfulBlock from './screenful-block';
+import VideoBlock from './video-block';
+export { AccordianBlock as AccordianBlockComponent, type BlockComponentProps, Blocks as BlocksComponent, CardBlock as CardBlockComponent, ContentComponent, CTABlock as CTABlockComponent, EnhHeadingBlock as EnhHeadingBlockComponent, GroupBlock as GroupBlockComponent, HeadingBlock as HeadingBlockComponent, ImageBlock as ImageBlockComponent, registerBlockType, SpaceBlock as SpaceBlockComponent, ScreenfulBlock as ScreenfulBlockComponent, VideoBlock as VideoBlockComponent, };

package/dist/blocks/components/index.js

@@ -0,0 +1,13 @@
+import AccordianBlock from './accordian-block';
+import Blocks from './content';
+import CardBlock from './card-block';
+import { default as ContentComponent, registerBlockType } from './content';
+import CTABlock from './cta-block';
+import EnhHeadingBlock from './enh-heading-block';
+import GroupBlock from './group-block';
+import HeadingBlock from './heading-block';
+import ImageBlock from './image-block';
+import SpaceBlock from './space-block';
+import ScreenfulBlock from './screenful-block';
+import VideoBlock from './video-block';
+export { AccordianBlock as AccordianBlockComponent, Blocks as BlocksComponent, CardBlock as CardBlockComponent, ContentComponent, CTABlock as CTABlockComponent, EnhHeadingBlock as EnhHeadingBlockComponent, GroupBlock as GroupBlockComponent, HeadingBlock as HeadingBlockComponent, ImageBlock as ImageBlockComponent, registerBlockType, SpaceBlock as SpaceBlockComponent, ScreenfulBlock as ScreenfulBlockComponent, VideoBlock as VideoBlockComponent, };

package/dist/blocks/components/screenful-block/content.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { ScreenfulBlock } from '../../def';
+declare const Content: React.FC<{
+    block: ScreenfulBlock;
+    agent?: string;
+    className?: string;
+}>;
+export default Content;