@nascentdigital/funnel-core 4.4.4

package/dist/types/index.js

@@ -0,0 +1,30 @@
+"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("./BoxedValue"), exports);
+__exportStar(require("./Callback"), exports);
+__exportStar(require("./DateString"), exports);
+__exportStar(require("./FilterConditionally"), exports);
+__exportStar(require("./MaybeConditionalValue"), exports);
+__exportStar(require("./Ordinal"), exports);
+__exportStar(require("./OverridableStringUnion"), exports);
+__exportStar(require("./PartialBy"), exports);
+__exportStar(require("./PickData"), exports);
+__exportStar(require("./Provider"), exports);
+__exportStar(require("./RequiredBy"), exports);
+__exportStar(require("./Result"), exports);
+__exportStar(require("./Timestamp"), exports);
+__exportStar(require("./Transform"), exports);

package/dist/ui/Accessible.d.ts

@@ -0,0 +1,5 @@
+export type Accessible = 'always' | 'never' | 'optional' | 'system';
+export declare namespace Accessible {
+    const values: ReadonlyArray<Accessible>;
+    function getName(accessible: Accessible): string;
+}

package/dist/ui/Accessible.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Accessible = void 0;
+const StringUtils_1 = require("../utils/StringUtils");
+// extension
+var Accessible;
+(function (Accessible) {
+    // constants
+    Accessible.values = ['always', 'never', 'optional', 'system'];
+    // helpers
+    function getName(accessible) {
+        return StringUtils_1.StringUtils.capitalize(accessible);
+    }
+    Accessible.getName = getName;
+})(Accessible || (exports.Accessible = Accessible = {}));

package/dist/ui/BlockThemes.d.ts

@@ -0,0 +1,19 @@
+import { OverridableStringUnion, PartialBy } from '../types';
+export type BlockThemes = Readonly<BlockThemes.Options>;
+export declare namespace BlockThemes {
+    type Theme = 'default';
+    namespace Theme {
+        type Extended = OverridableStringUnion<Theme, Overrides>;
+        interface Overrides {
+        }
+    }
+    type Option = {
+        name: string;
+        group?: string;
+        hint?: string;
+    };
+    type Options = Record<Theme.Extended, Option>;
+    function current(): Readonly<Options>;
+    function set<TTheme extends string = string>(themes: PartialBy<BlockThemes, 'default'>): void;
+    function getClassName(theme: Theme): string;
+}

package/dist/ui/BlockThemes.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockThemes = void 0;
+// extension
+var BlockThemes;
+(function (BlockThemes) {
+    // methods
+    function current() {
+        return _themes;
+    }
+    BlockThemes.current = current;
+    function set(themes) {
+        _themes = Object.assign(Object.assign({}, _default), themes);
+    }
+    BlockThemes.set = set;
+    function getClassName(theme) {
+        var _a;
+        // get entry
+        const { group = 'default' } = (_a = _themes[theme]) !== null && _a !== void 0 ? _a : {};
+        // render
+        return `nd-theme-${theme} nd-themeGroup-${group}`;
+    }
+    BlockThemes.getClassName = getClassName;
+})(BlockThemes || (exports.BlockThemes = BlockThemes = {}));
+// constants
+const _default = {
+    default: { name: 'Default', hint: 'The default theme' }
+};
+let _themes = _default;

package/dist/ui/ColorMode.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from 'rxjs';
+export type ColorMode = 'light' | 'dark';
+export declare namespace ColorMode {
+    /**
+     * Starts streaming `ColorMode` and changes, starting with the current value.
+     */
+    function current$(): Observable<ColorMode>;
+    /**
+     * Gets the current `ColorMode` value.
+     */
+    function current(): ColorMode;
+}

package/dist/ui/ColorMode.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorMode = void 0;
+const rxjs_1 = require("rxjs");
+const Browser_1 = require("./browser/Browser");
+// extension
+var ColorMode;
+(function (ColorMode) {
+    // internal behavior / subscription
+    let _colorMode = undefined;
+    function _current$() {
+        // return existing subject (if any)
+        if (_colorMode) {
+            return _colorMode;
+        }
+        // create fixed color mode subject if we're SSRing
+        const window = Browser_1.Browser.window;
+        if (!window) {
+            _colorMode = new rxjs_1.BehaviorSubject('light');
+        }
+        // or create active observing via browser (never ends)
+        else {
+            // create behavior with current value
+            const darkModePreference = window.matchMedia('(prefers-color-scheme: dark)');
+            const colorMode = new rxjs_1.BehaviorSubject(darkModePreference.matches ? 'dark' : 'light');
+            _colorMode = colorMode;
+            // update changes (forever)
+            darkModePreference.addEventListener('change', e => {
+                colorMode.next(e.matches ? 'dark' : 'light');
+            });
+        }
+        // return color mode
+        return _colorMode;
+    }
+    /**
+     * Starts streaming `ColorMode` and changes, starting with the current value.
+     */
+    function current$() {
+        return _current$().asObservable();
+    }
+    ColorMode.current$ = current$;
+    /**
+     * Gets the current `ColorMode` value.
+     */
+    function current() {
+        return _current$().getValue();
+    }
+    ColorMode.current = current;
+})(ColorMode || (exports.ColorMode = ColorMode = {}));

package/dist/ui/File.d.ts

@@ -0,0 +1,43 @@
+import { Tagged } from 'type-fest';
+import { ImageData } from './ImageSource';
+import { MimeType } from './MimeType';
+export type File = File.Image | File.Video | File.Audio | File.Document;
+export declare namespace File {
+    export type Id = Tagged<string, 'funnel.File.Id'>;
+    type Base = {
+        id: Id;
+        name: string;
+        url: string;
+        size: number;
+    };
+    export type Image = Base & {
+        mimeType: MimeType.Image;
+        width: number;
+        height: number;
+    };
+    export namespace Image {
+        function filter(value: any): value is Image;
+        function toImageData(image: Image): ImageData;
+    }
+    export type Video = Base & {
+        mimeType: MimeType.Video;
+    };
+    export namespace Video {
+        function filter(value: any): value is Video;
+    }
+    export type Audio = Base & {
+        mimeType: MimeType.Audio;
+    };
+    export namespace Audio {
+        function filter(value: any): value is Video;
+    }
+    export type Document = Base & {
+        mimeType: MimeType.Document;
+    };
+    export namespace Document {
+        function filter(value: any): value is Video;
+    }
+    export type Placeholder = Omit<Base, 'url' | 'size'>;
+    export function filter(value: any): value is File;
+    export {};
+}

package/dist/ui/File.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.File = void 0;
+const MimeType_1 = require("./MimeType");
+// extension
+var File;
+(function (File) {
+    let Image;
+    (function (Image) {
+        function filter(value) {
+            return File.filter(value) && MimeType_1.MimeType.image.includes(value.mimeType);
+        }
+        Image.filter = filter;
+        function toImageData(image) {
+            const { url, width, height } = image;
+            return {
+                src: url,
+                width,
+                height
+            };
+        }
+        Image.toImageData = toImageData;
+    })(Image = File.Image || (File.Image = {}));
+    let Video;
+    (function (Video) {
+        function filter(value) {
+            return File.filter(value) && MimeType_1.MimeType.video.includes(value.mimeType);
+        }
+        Video.filter = filter;
+    })(Video = File.Video || (File.Video = {}));
+    let Audio;
+    (function (Audio) {
+        function filter(value) {
+            return File.filter(value) && MimeType_1.MimeType.audio.includes(value.mimeType);
+        }
+        Audio.filter = filter;
+    })(Audio = File.Audio || (File.Audio = {}));
+    let Document;
+    (function (Document) {
+        function filter(value) {
+            return File.filter(value) && MimeType_1.MimeType.document.includes(value.mimeType);
+        }
+        Document.filter = filter;
+    })(Document = File.Document || (File.Document = {}));
+    // helpers
+    function filter(value) {
+        return !!value
+            && typeof value === 'object'
+            && !Array.isArray(value)
+            && 'id' in value && typeof value.id === 'string'
+            && 'url' in value && typeof value.url === 'string'
+            && 'mimeType' in value && typeof value.mimeType === 'string' && MimeType_1.MimeType.filter(value.mimeType);
+    }
+    File.filter = filter;
+})(File || (exports.File = File = {}));

package/dist/ui/FileType.d.ts

@@ -0,0 +1,8 @@
+import { MimeType } from './MimeType';
+export type FileType = 'image' | 'video' | 'icon' | 'audio' | 'document' | 'other';
+export declare namespace FileType {
+    const values: ReadonlyArray<FileType>;
+    function coerce(mimeType: MimeType): FileType;
+    function compare(lhs: FileType, rhs: FileType): 0 | 1 | -1;
+    function filter(value: any): value is FileType;
+}

package/dist/ui/FileType.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileType = void 0;
+// extension
+var FileType;
+(function (FileType) {
+    // values
+    FileType.values = ['image', 'video', 'icon', 'audio', 'document', 'other'];
+    // methods
+    function coerce(mimeType) {
+        switch (mimeType) {
+            case 'application/pdf':
+                return 'document';
+            case 'image/gif':
+            case 'image/jpeg':
+            case 'image/png':
+            case 'image/webp':
+                return 'image';
+            case 'image/svg+xml':
+                return 'icon';
+            case 'audio/mp3':
+            case 'audio/ogg':
+                return 'audio';
+            case 'video/mp4':
+            case 'video/webm':
+                return 'video';
+            default:
+                return 'other';
+        }
+    }
+    FileType.coerce = coerce;
+    function compare(lhs, rhs) {
+        const lhsIndex = FileType.values.indexOf(lhs);
+        const rhsIndex = FileType.values.indexOf(rhs);
+        return lhsIndex === rhsIndex
+            ? 0
+            : lhsIndex < rhsIndex
+                ? -1
+                : 1;
+    }
+    FileType.compare = compare;
+    function filter(value) {
+        return !!value
+            && typeof value === 'string'
+            && FileType.values.includes(value);
+    }
+    FileType.filter = filter;
+})(FileType || (exports.FileType = FileType = {}));

package/dist/ui/ImageSource.d.ts

@@ -0,0 +1,12 @@
+export type ImageSource = string | ImageData;
+export type ImageData = {
+    src: string;
+    width?: number;
+    height?: number;
+};
+export declare namespace ImageSource {
+    function coerce(value: any): ImageSource | undefined;
+}
+export declare namespace ImageData {
+    function filter(value: any): value is ImageData;
+}

package/dist/ui/ImageSource.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageData = exports.ImageSource = void 0;
+const File_1 = require("./File");
+// extensions
+var ImageSource;
+(function (ImageSource) {
+    function coerce(value) {
+        // handle next-js image format
+        if (ImageData.filter(value)) {
+            return value;
+        }
+        // also coerce image content
+        else if (File_1.File.Image.filter(value)) {
+            return File_1.File.Image.toImageData(value);
+        }
+        // handle source-like
+        else if (value && typeof value === 'object' && typeof value.src === 'string') {
+            return value.src;
+        }
+        // or just raw value
+        else if (value && typeof value === 'string') {
+            return value;
+        }
+        // or URL
+        else if (value && value instanceof URL) {
+            return value.href;
+        }
+        // fallback to undefined
+        return undefined;
+    }
+    ImageSource.coerce = coerce;
+})(ImageSource || (exports.ImageSource = ImageSource = {}));
+var ImageData;
+(function (ImageData) {
+    function filter(value) {
+        // skip if not an object
+        if (typeof value !== 'object') {
+            return false;
+        }
+        // check properties to match
+        const data = value;
+        return data && data.src && typeof data.src === 'string'
+            && data.width && typeof data.width === 'number'
+            && data.height && typeof data.height === 'number';
+    }
+    ImageData.filter = filter;
+})(ImageData || (exports.ImageData = ImageData = {}));

package/dist/ui/MimeType.d.ts

@@ -0,0 +1,28 @@
+import { FileType } from './FileType';
+export type MimeType = MimeType.Image | MimeType.Video | MimeType.Audio | MimeType.Document;
+export declare namespace MimeType {
+    const image: readonly ["image/jpeg", "image/png", "image/gif", "image/webp", "image/svg+xml"];
+    const video: readonly ["video/mp4", "video/webm"];
+    const audio: readonly ["audio/mp3", "audio/ogg"];
+    const document: readonly ["application/pdf"];
+    const any: readonly ["image/jpeg", "image/png", "image/gif", "image/webp", "image/svg+xml", "video/mp4", "video/webm", "audio/mp3", "audio/ogg", "application/pdf"];
+    type Image = typeof image[number];
+    namespace Image {
+        function filter(value: MimeType): value is Image;
+    }
+    type Video = typeof video[number];
+    namespace Video {
+        function filter(value: MimeType): value is Image;
+    }
+    namespace Visual {
+        function filter(value: MimeType): value is Image | Video;
+        function filterRaster(value: MimeType): value is Image | Video;
+    }
+    type Audio = typeof audio[number];
+    type Document = typeof document[number];
+    const values: ReadonlyArray<MimeType>;
+    function filter(value: any): value is MimeType;
+    function getFileType(mimeType: MimeType): FileType;
+    function getFileExtension(mimeType: MimeType): string;
+    function forFileType(fileType: FileType): MimeType[];
+}

package/dist/ui/MimeType.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MimeType = void 0;
+const errors_1 = require("../errors");
+// extension
+var MimeType;
+(function (MimeType) {
+    // formats
+    MimeType.image = ['image/jpeg', 'image/png', 'image/gif', 'image/webp', 'image/svg+xml'];
+    MimeType.video = ['video/mp4', 'video/webm'];
+    MimeType.audio = ['audio/mp3', 'audio/ogg'];
+    MimeType.document = ['application/pdf'];
+    MimeType.any = [...MimeType.image, ...MimeType.video, ...MimeType.audio, ...MimeType.document];
+    let Image;
+    (function (Image) {
+        function filter(value) {
+            return MimeType.image.includes(value);
+        }
+        Image.filter = filter;
+    })(Image = MimeType.Image || (MimeType.Image = {}));
+    let Video;
+    (function (Video) {
+        function filter(value) {
+            return MimeType.video.includes(value);
+        }
+        Video.filter = filter;
+    })(Video = MimeType.Video || (MimeType.Video = {}));
+    let Visual;
+    (function (Visual) {
+        function filter(value) {
+            return Image.filter(value) || Video.filter(value);
+        }
+        Visual.filter = filter;
+        function filterRaster(value) {
+            return (Image.filter(value) && value !== 'image/svg+xml') || Video.filter(value);
+        }
+        Visual.filterRaster = filterRaster;
+    })(Visual = MimeType.Visual || (MimeType.Visual = {}));
+    // all
+    MimeType.values = [...MimeType.image, ...MimeType.video, ...MimeType.image, ...MimeType.document];
+    // helpers
+    function filter(value) {
+        return !!value
+            && typeof value === 'string'
+            && MimeType.values.includes(value);
+    }
+    MimeType.filter = filter;
+    function getFileType(mimeType) {
+        if (MimeType.image.includes(mimeType)) {
+            return 'image';
+        }
+        else if (MimeType.video.includes(mimeType)) {
+            return 'video';
+        }
+        else if (MimeType.audio.includes(mimeType)) {
+            return 'audio';
+        }
+        else if (MimeType.document.includes(mimeType)) {
+            return 'document';
+        }
+        else {
+            return 'other';
+        }
+    }
+    MimeType.getFileType = getFileType;
+    function getFileExtension(mimeType) {
+        switch (mimeType) {
+            case 'image/gif':
+                return 'gif';
+            case 'image/jpeg':
+                return 'jpeg';
+            case 'image/png':
+                return 'png';
+            case 'image/webp':
+                return 'webp';
+            case 'image/svg+xml':
+                return 'svg';
+            case 'video/mp4':
+                return 'mp4';
+            case 'video/webm':
+                return 'webm';
+            case 'audio/mp3':
+                return 'mp3';
+            case 'audio/ogg':
+                return 'ogg';
+            case 'application/pdf':
+                return 'pdf';
+            default:
+                return '?';
+        }
+    }
+    MimeType.getFileExtension = getFileExtension;
+    function forFileType(fileType) {
+        switch (fileType) {
+            case 'image':
+                return [...MimeType.image];
+            case 'icon':
+                return ['image/svg+xml'];
+            case 'video':
+                return [...MimeType.video];
+            case 'audio':
+                return [...MimeType.audio];
+            case 'document':
+                return [...MimeType.document];
+            default:
+                throw new errors_1.NotImplementedError(`No support for FileType "${fileType}"`);
+        }
+    }
+    MimeType.forFileType = forFileType;
+})(MimeType || (exports.MimeType = MimeType = {}));

package/dist/ui/Placement.d.ts

@@ -0,0 +1,21 @@
+import { Frame, Insets, Rect, Size } from './geometry';
+export type Placement = Placement.Side | `${Placement.Side}-${Placement.Anchor}`;
+export declare namespace Placement {
+    type Side = 'top' | 'bottom' | 'left' | 'right';
+    type Anchor = 'start' | 'end' | 'match';
+    type Components = {
+        side: Side;
+        anchor?: Anchor;
+    };
+    function getComponents(placement: Placement): Components;
+    type RelativeTo = {};
+    type ForContentArgs = {
+        containerRect: Rect;
+        containerPadding?: number | Insets;
+        anchorRect: Rect;
+        anchorOffset?: number;
+        placement: Placement;
+        contentSize: Readonly<Size>;
+    };
+    function forContent({ containerRect, containerPadding, anchorRect, anchorOffset, placement, contentSize }: ForContentArgs): Partial<Frame>;
+}