@nascentdigital/funnel-ui 4.4.18

package/dist/client/transitions/reveal/RevealController.js

@@ -0,0 +1,114 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RevealController = RevealController;
+const react_1 = require("react");
+const motion_1 = require("motion");
+const useMixedResponsiveValue_1 = require("../../hooks/useMixedResponsiveValue");
+function RevealController({ scroller = 'body', targetContainer, inViewTrigger, percentVisible = 0.8, triggerOffsetPx = 0, animations, }) {
+    // extract current values from responsive props
+    const _animations = (0, useMixedResponsiveValue_1.useMixedResponsiveValue)(animations);
+    const _triggerOffsetPx = (0, useMixedResponsiveValue_1.useMixedResponsiveValue)(triggerOffsetPx);
+    const _percentVisible = (0, useMixedResponsiveValue_1.useMixedResponsiveValue)(percentVisible);
+    // Intersection Observer
+    (0, react_1.useEffect)(() => {
+        // exit early if no animations
+        if (!_animations) {
+            return;
+        }
+        // set initial animation states
+        setInitialAnimationAttributes(targetContainer, _animations);
+        const options = {
+            root: document.querySelector(scroller),
+            rootMargin: `${_triggerOffsetPx}px`,
+            threshold: _percentVisible,
+        };
+        let animation;
+        // declare callback for targets entering/exiting viewport
+        const onObservationChanged = (entries) => {
+            entries.forEach((entry) => {
+                // check if object is intersection
+                if (entry.isIntersecting) {
+                    // run animations
+                    animation = (0, motion_1.animate)(sequenceFromAnimationOptions(targetContainer, _animations));
+                }
+            });
+        };
+        // create intersection observer
+        const observer = new IntersectionObserver(onObservationChanged, options);
+        // observe trigger element
+        const triggerElement = document.querySelector(`${targetContainer} ${inViewTrigger !== null && inViewTrigger !== void 0 ? inViewTrigger : ''}`);
+        // exit early if trigger element doesn't exist
+        if (!triggerElement) {
+            console.warn(`[RevealController]: trigger element with selector: ${triggerElement} not found`);
+            return;
+        }
+        // start observing trigger element
+        observer.observe(triggerElement);
+        // disconnect intersection observer from DOM
+        return () => {
+            // cancel animation
+            animation === null || animation === void 0 ? void 0 : animation.cancel();
+            // reset initial animation states
+            resetInitialAnimationAttributes(targetContainer, _animations);
+            // stop observing
+            observer.disconnect();
+        };
+    }, [inViewTrigger, scroller, _animations, targetContainer, _triggerOffsetPx, _percentVisible]);
+    return null;
+}
+function setInitialAnimationAttributes(parentSelector, initialOptions) {
+    initialOptions.forEach(({ selector, from, attribute }) => {
+        const element = document.querySelector(`${parentSelector} ${selector}`);
+        if (!element) {
+            console.warn(`[RevealController]: target element for found for selector: ${selector}`);
+            return;
+        }
+        setStyleForAttribute(element, attribute, from);
+    });
+}
+function resetInitialAnimationAttributes(parentSelector, initialOptions) {
+    initialOptions.forEach(({ selector, from, attribute }) => {
+        const element = document.querySelector(`${parentSelector} ${selector}`);
+        if (!element) {
+            console.warn(`[RevealController]: target element for found for selector: ${selector}`);
+            return;
+        }
+        resetStyleForAttribute(element, attribute);
+    });
+}
+function resetStyleForAttribute(element, attribute) {
+    switch (attribute) {
+        case 'x':
+        case 'y':
+            return element.style.removeProperty('transform');
+        default:
+            return element.style.removeProperty(attribute);
+    }
+}
+function setStyleForAttribute(element, attribute, value) {
+    switch (attribute) {
+        case 'x':
+            return element.style.transform = `translateX(${value}px)`;
+        case 'y':
+            return element.style.transform = `translateY(${value}px)`;
+        default:
+            return element.style.setProperty(attribute, `${value}`);
+    }
+}
+function sequenceFromAnimationOptions(parentSelector, animationOptions) {
+    return animationOptions.map(({ selector, attribute, to, delay, duration, parallel }) => {
+        const at = parallel ? '<' : undefined;
+        return [
+            `${parentSelector} ${selector}`,
+            {
+                [attribute]: to
+            },
+            {
+                delay,
+                duration,
+                at
+            }
+        ];
+    });
+}

package/dist/client/transitions/reveal/RevealElementAnimator.d.ts

@@ -0,0 +1,13 @@
+import { RevealAnimation } from './RevealAnimation';
+export declare class RevealElementAnimator {
+    private readonly runInParallel;
+    animationList: RevealAnimation.Options[];
+    constructor(runInParallel?: boolean);
+    fadeIn(selector: string, overrides?: RevealAnimation.ConfigurableOptions): void;
+    slideDown(selector: string, overrides?: RevealAnimation.ConfigurableOptions): void;
+    slideUp(selector: string, overrides?: RevealAnimation.ConfigurableOptions): void;
+    slideLeft(selector: string, overrides?: RevealAnimation.ConfigurableOptions): void;
+    slideRight(selector: string, overrides?: RevealAnimation.ConfigurableOptions): void;
+    fadeAndSlideUp(selector: string, overrides?: RevealAnimation.ConfigurableOptions): void;
+    private addAnimation;
+}

package/dist/client/transitions/reveal/RevealElementAnimator.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RevealElementAnimator = void 0;
+class RevealElementAnimator {
+    constructor(runInParallel = false) {
+        this.animationList = [];
+        this.runInParallel = runInParallel;
+    }
+    fadeIn(selector, overrides) {
+        this.addAnimation({
+            selector,
+            attribute: 'opacity',
+            from: 0,
+            to: 1,
+        }, overrides);
+    }
+    slideDown(selector, overrides) {
+        this.addAnimation({
+            selector,
+            attribute: 'y',
+            from: -100,
+            to: 0,
+        }, overrides);
+    }
+    slideUp(selector, overrides) {
+        this.addAnimation({
+            selector,
+            attribute: 'y',
+            from: 100,
+            to: 0,
+        }, overrides);
+    }
+    slideLeft(selector, overrides) {
+        this.addAnimation({
+            selector,
+            attribute: 'x',
+            from: 100,
+            to: 0,
+        }, overrides);
+    }
+    slideRight(selector, overrides) {
+        this.addAnimation({
+            selector,
+            attribute: 'x',
+            from: -100,
+            to: 0,
+        }, overrides);
+    }
+    // composed animations
+    fadeAndSlideUp(selector, overrides) {
+        // create new parallel animator
+        const animator = new RevealElementAnimator(true);
+        // run both fade in and slide up
+        animator.fadeIn(selector, overrides);
+        animator.slideUp(selector, overrides);
+        // add to current animation list
+        this.animationList = this.animationList.concat(animator.animationList);
+    }
+    addAnimation(options, overrides) {
+        // first animation in parallel should not have parallel set to true, it needs to happen following any previous ones
+        const shouldRunInParallel = this.runInParallel && this.animationList.length >= 1;
+        this.animationList.push(Object.assign(Object.assign(Object.assign({ duration: 0.5 }, options), overrides), { parallel: shouldRunInParallel }));
+    }
+}
+exports.RevealElementAnimator = RevealElementAnimator;

package/dist/client/transitions/reveal/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Reveal';
+export * from './RevealController';

package/dist/client/transitions/reveal/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Reveal"), exports);
+__exportStar(require("./RevealController"), exports);

package/dist/client/utils/OnKey.d.ts

@@ -0,0 +1,20 @@
+import { Callback } from '@nascentdigital/funnel-core';
+import { KeyboardEvent, KeyboardEventHandler } from 'react';
+export declare namespace OnKey {
+    type Target = {
+        key: string;
+        shift?: boolean;
+        ctrl?: boolean;
+        alt?: boolean;
+        meta?: boolean;
+    };
+    namespace Target {
+        function matches<T extends HTMLElement = HTMLElement>(target: Target, e: KeyboardEvent<T>): boolean;
+    }
+    function enter<T extends HTMLElement = HTMLElement>(callback: Callback<KeyboardEvent<T>>): KeyboardEventHandler<T>;
+    function esc<T extends HTMLElement = HTMLElement>(callback: Callback<KeyboardEvent<T>>): KeyboardEventHandler<T>;
+    type HandleArgs = {
+        target: Target | Target[];
+    };
+    function handle<T extends HTMLElement>(callback: Callback<KeyboardEvent<T>>, ...targets: Target[]): KeyboardEventHandler<T>;
+}

package/dist/client/utils/OnKey.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnKey = void 0;
+var OnKey;
+(function (OnKey) {
+    let Target;
+    (function (Target) {
+        function matches(target, e) {
+            return target.key === e.key
+                && (target.shift === undefined || target.shift == e.shiftKey)
+                && (target.alt === undefined || target.alt == e.altKey)
+                && (target.ctrl === undefined || target.ctrl == e.ctrlKey)
+                && (target.meta === undefined || target.alt == e.metaKey);
+        }
+        Target.matches = matches;
+    })(Target = OnKey.Target || (OnKey.Target = {}));
+    function enter(callback) {
+        return handle(callback, { key: 'Enter' });
+    }
+    OnKey.enter = enter;
+    function esc(callback) {
+        return handle(callback, { key: 'Escape' });
+    }
+    OnKey.esc = esc;
+    function handle(callback, ...targets) {
+        return (e) => {
+            if (targets.some(target => Target.matches(target, e))) {
+                callback(e);
+            }
+        };
+    }
+    OnKey.handle = handle;
+})(OnKey || (exports.OnKey = OnKey = {}));

package/dist/client/utils/SharedMutationObserver.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+export declare class SharedMutationObserver {
+    private static _instance?;
+    private readonly _observer;
+    private readonly _callbacks;
+    static get instance(): SharedMutationObserver;
+    private constructor();
+    private get observer();
+    watch(element: Element, scope?: ReadonlyArray<SharedMutationObserver.Scope>): Observable<SharedMutationObserver.Change>;
+    private onDisconnect;
+    private rebind;
+    private onMutate;
+}
+export declare namespace SharedMutationObserver {
+    type Scope = 'attributes' | 'children' | 'subtree';
+    type Change = {
+        element: Element;
+        scope: ReadonlySet<Scope>;
+    };
+}

package/dist/client/utils/SharedMutationObserver.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedMutationObserver = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const rxjs_1 = require("rxjs");
+// class
+class SharedMutationObserver {
+    static get instance() {
+        // create if required
+        if (!SharedMutationObserver._instance) {
+            SharedMutationObserver._instance = new SharedMutationObserver();
+        }
+        // throw if we don't have the instance
+        const instance = SharedMutationObserver._instance;
+        if (!instance) {
+            throw new funnel_core_1.IllegalStateError('Unable to instantiate SharedMutationObserver');
+        }
+        // return instance
+        return instance;
+    }
+    constructor() {
+        // bind callback
+        this.onMutate = this.onMutate.bind(this);
+        // initialize instance
+        this._observer = typeof window === 'undefined'
+            ? undefined
+            : new MutationObserver(this.onMutate);
+        this._callbacks = new Map();
+    }
+    get observer() {
+        // throw if the observer isn't bound
+        const { _observer } = this;
+        if (!_observer) {
+            throw new funnel_core_1.InvalidOperationError('Attempt to access unbound observer');
+        }
+        // return observer
+        return _observer;
+    }
+    watch(element, scope = ['children']) {
+        // get active subscriptions (or create set)
+        const { _callbacks } = this;
+        let subscriptions = _callbacks.get(element);
+        if (!subscriptions) {
+            subscriptions = [];
+            _callbacks.set(element, subscriptions);
+        }
+        // determine existing scope
+        const existingScope = Subscription.mergeScope(subscriptions);
+        // create new subscription (and track it)
+        const subject = new rxjs_1.Subject();
+        subject.next(true);
+        subject.unsubscribe();
+        const subscription = new Subscription({
+            element,
+            scope,
+            disconnect: () => this.onDisconnect(subscription)
+        });
+        subscriptions.push(subscription);
+        // rebind observer if we need to (it rebinds ALL observations)
+        if (!subscription.scope.isSubsetOf(existingScope)) {
+            this.rebind();
+        }
+        // return subscription id
+        return subscription.observable;
+    }
+    onDisconnect(subscription) {
+        // skip if it's not subscribed
+        const { _callbacks } = this;
+        const subscriptions = _callbacks.get(subscription.element);
+        if (!subscriptions) {
+            console.warn('[SharedMutationObserver/onDisconnect] no subscriptions registered');
+            return;
+        }
+        // remove subscription
+        const subscriptionIndex = subscriptions.indexOf(subscription);
+        if (subscriptionIndex >= 0) {
+            subscriptions.splice(subscriptionIndex, 1);
+        }
+        // or skip if it's already removed
+        else {
+            console.warn('[SharedMutationObserver/onDisconnect] cannot find subscription');
+            return;
+        }
+        // remove entry if there are no more subscriptions (forces rebind)
+        if (subscriptions.length === 0) {
+            // drop mapping
+            _callbacks.delete(subscription.element);
+            // rebind
+            this.rebind();
+        }
+        // or rebind if scope has changed
+        else if (!subscription.scope.isSubsetOf(Subscription.mergeScope(subscriptions))) {
+            this.rebind();
+        }
+    }
+    rebind() {
+        // disconnect observer
+        const { observer, _callbacks } = this;
+        observer.disconnect();
+        // connect observer to callbacks
+        for (const [element, subscriptions] of _callbacks) {
+            // determine scope for element
+            const scope = Subscription.mergeScope(subscriptions);
+            // wire observer
+            observer.observe(element, {
+                attributes: scope.has('attributes'),
+                childList: scope.has('children'),
+                subtree: scope.has('subtree')
+            });
+        }
+    }
+    onMutate(mutations) {
+        // aggregate changes
+        const changes = new Map();
+        for (const mutation of mutations) {
+            // get existing changes (or create new set)
+            const target = mutation.target;
+            let scope = changes.get(target);
+            if (!scope) {
+                scope = new Set();
+                changes.set(target, scope);
+            }
+            // add changes
+            switch (mutation.type) {
+                case 'attributes':
+                    scope.add('attributes');
+                    break;
+                case 'childList':
+                    if (mutation.addedNodes.length > 0) {
+                        scope.add(Array.from(mutation.addedNodes.values()).some(node => node.parentElement !== target)
+                            ? 'subtree'
+                            : 'children');
+                    }
+                    if (mutation.removedNodes.length > 0) {
+                        scope.add(Array.from(mutation.removedNodes.values()).some(node => node.parentElement !== target)
+                            ? 'subtree'
+                            : 'children');
+                    }
+                    break;
+            }
+        }
+        // fire off callbacks (if any)
+        const { _callbacks } = this;
+        for (const [element, scope] of changes) {
+            // get subscriptions for element (or skip if there's none)
+            const subscriptions = _callbacks.get(element);
+            if (!subscriptions) {
+                continue;
+            }
+            // callback for any matching scope
+            for (const subscription of subscriptions) {
+                // determine subscribed scope
+                const subscribedScope = subscription.scope.union(scope);
+                // callback if there's any match
+                if (subscribedScope.size > 0) {
+                    subscription.onChange(subscribedScope);
+                }
+            }
+        }
+    }
+}
+exports.SharedMutationObserver = SharedMutationObserver;
+// subscription
+class Subscription {
+    constructor(args) {
+        // initialize instance variables
+        this.element = args.element;
+        this.scope = new Set(args.scope.length === 0 ? ['children'] : args.scope);
+        this.observable = new rxjs_1.Observable(subscriber => {
+            // bind subscriber
+            this._subscriber = subscriber;
+            // disconnect on unsubscribe
+            return () => {
+                // unhook subscriber
+                delete this._subscriber;
+                // disconnect
+                args.disconnect();
+                // raise completion
+                subscriber.complete();
+            };
+        });
+    }
+    onChange(scope) {
+        // throw if subscriber isn't bound
+        const { element, _subscriber } = this;
+        if (!_subscriber) {
+            throw new funnel_core_1.InvalidOperationError('Cannot raise change before subscriber is bound  ');
+        }
+        // raise change
+        _subscriber.next({
+            element,
+            scope
+        });
+    }
+}
+(function (Subscription) {
+    // helpers
+    function mergeScope(subscriptions) {
+        return new Set(subscriptions.flatMap(subscription => Array.from(subscription.scope.values())));
+    }
+    Subscription.mergeScope = mergeScope;
+})(Subscription || (Subscription = {}));

package/dist/client/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './OnKey';
+export * from './SharedMutationObserver';

package/dist/client/utils/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./OnKey"), exports);
+__exportStar(require("./SharedMutationObserver"), exports);

package/dist/server/atomic/Markup.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export declare function Markup({ markdown, disableWrapper, ...props }: Markup.Props): import("react/jsx-runtime").JSX.Element;
+export declare namespace Markup {
+    type DisableWrapper = {
+        disableWrapper: true;
+        className?: undefined;
+    } | {
+        disableWrapper?: false;
+        className?: string;
+    };
+    type Props = Omit<React.HTMLAttributes<Element>, 'children' | 'className'> & {
+        markdown: string;
+    } & DisableWrapper;
+}

package/dist/server/atomic/Markup.js

@@ -0,0 +1,34 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Markup = Markup;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const markdown_to_jsx_1 = __importDefault(require("markdown-to-jsx"));
+const react_1 = __importDefault(require("react"));
+// component
+function Markup(_a) {
+    var { markdown = '', disableWrapper = false } = _a, props = __rest(_a, ["markdown", "disableWrapper"]);
+    // render
+    return ((0, jsx_runtime_1.jsx)(markdown_to_jsx_1.default, Object.assign({ options: {
+            wrapper: disableWrapper ? react_1.default.Fragment : undefined,
+            disableAutoLink: true,
+            namedCodesToUnicode
+        }, children: markdown }, props)));
+}
+// customization
+const namedCodesToUnicode = {
+    '#x20': ' '
+};

package/dist/server/atomic/NascentLogo.d.ts

@@ -0,0 +1,6 @@
+export declare function NascentLogo({ className }: NascentLogo.Props): import("react/jsx-runtime").JSX.Element;
+export declare namespace NascentLogo {
+    type Props = {
+        className?: string;
+    };
+}

package/dist/server/atomic/NascentLogo.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NascentLogo = NascentLogo;
+const jsx_runtime_1 = require("react/jsx-runtime");
+// component
+function NascentLogo({ className }) {
+    // render
+    return ((0, jsx_runtime_1.jsx)("svg", { className: className, xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 44 48", children: (0, jsx_runtime_1.jsx)("path", { d: "M33.504 29.5541V1.33332H42.5936V41.5219L33.504 29.5541ZM42.5579 46.6771C42.5592 46.6896 42.5576 46.6951 42.5579 46.6953C42.5544 46.6982 42.5428 46.7017 42.5346 46.7022H33.475V31.6333L42.5574 43.6009V46.6665L42.5579 46.6771ZM11.7657 18.2386V3.06298L32.178 29.947V45.1295L11.7657 18.2386ZM1.37603 4.50607V1.36895H10.4656V16.5435L1.37603 4.50607ZM1.34035 46.7379V6.62125L10.4656 18.6668V46.7379H1.34035ZM0.000995636 46.8237C0.0891113 47.4724 0.69035 48 1.34132 48H10.4666C11.1704 48 11.7651 47.4058 11.7651 46.7024V20.3529L32.4528 47.5278C32.7065 47.8235 33.0729 48 33.4331 48H42.5583C43.2622 48 43.8568 47.4058 43.8568 46.7024V1.29762C43.8568 0.594227 43.2622 0 42.5583 0H33.4331C32.7292 0 32.1346 0.594227 32.1346 1.29762V27.8601L11.5259 0.696041C11.2996 0.316078 10.9085 0.106949 10.4238 0.106949H1.29851C0.594677 0.106949 0 0.701248 0 1.40464V46.8093L0.000995636 46.8237Z", fillRule: "evenodd", clipRule: "evenodd" }) }));
+}

package/dist/server/atomic/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Markup';
+export * from './NascentLogo';

package/dist/server/atomic/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Markup"), exports);
+__exportStar(require("./NascentLogo"), exports);

package/dist/server/blocks/Block.d.ts

@@ -0,0 +1,16 @@
+import { BlockLayout, Transform } from '@nascentdigital/funnel-core';
+import { ReactNode } from 'react';
+import { HTMLBlockElement } from '../../types';
+import { BlockConfig } from '../schema';
+export declare function Block({ className, config, layout, renderPanel, ...props }: Block.Props): import("react/jsx-runtime").JSX.Element;
+export declare namespace Block {
+    type Props = HTMLBlockElement<'div'> & {
+        config?: BlockConfig.Presets.ThemeOnly;
+        layout: BlockLayout;
+        renderPanel: Transform<RenderPanelArgs, ReactNode>;
+    };
+    type RenderPanelArgs = {
+        className?: string;
+        panel: BlockLayout.Panel;
+    };
+}