@neovici/cosmoz-utils 4.0.0-beta.1 → 5.0.0

package/dist/array.d.ts

@@ -0,0 +1 @@
+export declare const array: (arr: unknown) => any[], without: (exclude: unknown, predicate?: <T>(obj: T) => T) => (list: unknown) => any[];

package/dist/array.js

@@ -0,0 +1,24 @@
+import { identity } from './function';
+const isIterable = (x) => {
+    return typeof x === 'object' && x !== null && Symbol.iterator in x;
+};
+export const array = (arr) => {
+    if (arr == null) {
+        return [];
+    }
+    if (Array.isArray(arr)) {
+        return arr;
+    }
+    if (typeof arr === 'string') {
+        return [arr];
+    }
+    if (isIterable(arr)) {
+        return Array.from(arr);
+    }
+    return [arr];
+}, 
+// TODO: Improve definition
+without = (exclude, predicate = identity) => (list) => {
+    const excludes = array(exclude).map(predicate);
+    return array(list).filter((value) => !excludes.includes(predicate(value)));
+};

package/dist/date.d.ts

@@ -0,0 +1,39 @@
+declare const 
+/**
+ * Validate a Date object or date string.
+ * @param {date/string} date Date to check.
+ * @return {date} Validated date or undefined on failure.
+ */
+ensureDate: <T>(date: T) => Date | undefined, 
+/**
+ * Format a date as an ISO-date - YYYY-MM-DD.
+ * @param {date/string} date Date to be ISO formatted.
+ * @return {string} ISO formatted date.
+ */
+isoDate: <T>(date: T) => string, 
+/**
+ * Format a date with time as an ISO date with time - YYYY-MM-DD HH:mm:ss.
+ * @param	 {date/string} date Date to be ISO formatted.
+ * @return {string} ISO formatted date.
+ */
+isoDT: <T>(date: T) => string, 
+/**
+ * Check if date is in the past.
+ * @param	 {date/string} date Date to check.
+ * @return {boolean} Whether the date is in the past or not.
+ */
+pastDate: <T>(date: T) => boolean | undefined, 
+/**
+ * Get human readable string describing date's difference from now in the current locale language.
+ * @param {date/string} date Date to check.
+ * @param {string} locale Localized lang to return string in (undefined = browser)
+ * @return {string}		Date representation string in the current locale language.
+ */
+timeago: <T>(date: T, locale?: string) => string, 
+/**
+ * Alias for isoDate(date), format a date as an ISO-date - YYYY-MM-DD.
+ * @param	 {date/string} date Date to be formatted.
+ * @return {string} ISO formatted date.
+ */
+renderDate: <T>(date: T) => string, pad: (number: number) => string | number, toLocalISOString: <T>(date: T) => string | null, parseDate: (str: string) => Date | undefined, inputDate: <T>(date: T) => string | undefined;
+export { ensureDate, isoDate, isoDT, pad, pastDate, renderDate, toLocalISOString, timeago, parseDate, inputDate, };

package/dist/date.js

@@ -0,0 +1,147 @@
+const getValUnitDiff = (date1, date2) => {
+    const msDiff = date1.getTime() - date2.getTime(), secDiff = msDiff / 1000, minDiff = secDiff / 60, hourDiff = minDiff / 60, dayDiff = hourDiff / 24, monthDiff = dayDiff / 30, yearDiff = monthDiff / 12;
+    if (Math.abs(yearDiff) >= 1) {
+        return [yearDiff, 'year'];
+    }
+    if (Math.abs(monthDiff) >= 1) {
+        return [monthDiff, 'month'];
+    }
+    if (Math.abs(dayDiff) >= 1) {
+        return [dayDiff, 'day'];
+    }
+    if (Math.abs(hourDiff) >= 1) {
+        return [hourDiff, 'hour'];
+    }
+    if (Math.abs(minDiff) >= 1) {
+        return [minDiff, 'minute'];
+    }
+    return [secDiff, 'second'];
+}, rules = { isoBasic: /^\d{4}-\d{2}-\d{2}$/iu }, parse = (val) => {
+    if (typeof val === 'string' && rules.isoBasic.test(val)) {
+        return new Date(`${val}T00:00`);
+    }
+    return new Date(val);
+}, 
+/**
+ * Validate a Date object or date string.
+ * @param {date/string} date Date to check.
+ * @return {date} Validated date or undefined on failure.
+ */
+ensureDate = (date) => {
+    if (date == null) {
+        return;
+    }
+    if (date instanceof Date && !isNaN(date.getTime())) {
+        return date;
+    }
+    if (!(typeof date === 'number' || typeof date === 'string')) {
+        return;
+    }
+    const ensuredDate = parse(date);
+    if (ensuredDate instanceof Date && isNaN(ensuredDate.getTime())) {
+        return;
+    }
+    return ensuredDate;
+}, 
+/**
+ * Format a date as an ISO-date - YYYY-MM-DD.
+ * @param {date/string} date Date to be ISO formatted.
+ * @return {string} ISO formatted date.
+ */
+isoDate = (date) => {
+    const d = ensureDate(date);
+    if (d == null) {
+        return '';
+    }
+    // Sweden uses ISO8601 human-readable
+    return d.toLocaleDateString('sv', {
+        year: 'numeric',
+        month: 'numeric',
+        day: 'numeric',
+    });
+}, 
+/**
+ * Format a date with time as an ISO date with time - YYYY-MM-DD HH:mm:ss.
+ * @param	 {date/string} date Date to be ISO formatted.
+ * @return {string} ISO formatted date.
+ */
+isoDT = (date) => {
+    const d = ensureDate(date);
+    if (d == null) {
+        return '';
+    }
+    // Sweden uses ISO8601 human-readable
+    return d.toLocaleDateString('sv', {
+        year: 'numeric',
+        month: 'numeric',
+        day: 'numeric',
+        hour: 'numeric',
+        minute: 'numeric',
+        second: 'numeric',
+    });
+}, 
+/**
+ * Check if date is in the past.
+ * @param	 {date/string} date Date to check.
+ * @return {boolean} Whether the date is in the past or not.
+ */
+pastDate = (date) => {
+    const d = ensureDate(date);
+    if (d == null) {
+        return;
+    }
+    return d.getTime() < Date.now();
+}, 
+/**
+ * Get human readable string describing date's difference from now in the current locale language.
+ * @param {date/string} date Date to check.
+ * @param {string} locale Localized lang to return string in (undefined = browser)
+ * @return {string}		Date representation string in the current locale language.
+ */
+timeago = (date, locale) => {
+    const d = ensureDate(date);
+    if (d == null) {
+        return '';
+    }
+    return new Intl.RelativeTimeFormat(locale, {
+        localeMatcher: 'best fit',
+        numeric: 'auto',
+        style: 'long', // other values: "short" or "narrow"
+    }).format(...getValUnitDiff(d, new Date()));
+}, 
+/**
+ * Alias for isoDate(date), format a date as an ISO-date - YYYY-MM-DD.
+ * @param	 {date/string} date Date to be formatted.
+ * @return {string} ISO formatted date.
+ */
+renderDate = isoDate, pad = (number) => (number < 10 ? '0' + number : number), toLocalISOString = (date) => {
+    if (!(date instanceof Date)) {
+        return null;
+    }
+    return (date.getFullYear() +
+        '-' +
+        pad(date.getMonth() + 1) +
+        '-' +
+        pad(date.getDate()) +
+        'T' +
+        pad(date.getHours()) +
+        ':' +
+        pad(date.getMinutes()) +
+        ':' +
+        pad(date.getSeconds()) +
+        '.' +
+        (date.getMilliseconds() / 1000).toFixed(3).slice(2, 5));
+}, parseDate = (str) => {
+    const ts = Date.parse(str);
+    if (isNaN(ts)) {
+        return;
+    }
+    return new Date(ts);
+}, inputDate = (date) => {
+    const d = ensureDate(date);
+    if (d == null) {
+        return;
+    }
+    return (d.getFullYear() + '-' + pad(d.getMonth() + 1) + '-' + pad(d.getDate()));
+};
+export { ensureDate, isoDate, isoDT, pad, pastDate, renderDate, toLocalISOString, timeago, parseDate, inputDate, };

package/dist/directives/lazy-until.d.ts

@@ -0,0 +1,46 @@
+export class UntilDirective extends AsyncDirective {
+    __lastRenderedIndex: number;
+    __values: any[];
+    __weakThis: PseudoWeakRef;
+    __pauser: Pauser;
+    render(...args: any[]): any;
+    update(_part: any, args: any): any;
+}
+/**
+ * Renders one of a series of values, including Promises, to a Part.
+ *
+ * Values are rendered in priority order, with the first argument having the
+ * highest priority and the last argument having the lowest priority. If a
+ * value is a Promise, low-priority values will be rendered until it resolves.
+ *
+ * The priority of values can be used to create placeholder content for async
+ * data. For example, a Promise with pending content can be the first,
+ * highest-priority, argument, and a non_promise loading indicator template can
+ * be used as the second, lower-priority, argument. The loading indicator will
+ * render immediately, and the primary content will render when the Promise
+ * resolves.
+ *
+ * Example:
+ *
+ * ```js
+ * const content = fetch('./content.txt').then(r => r.text());
+ * html`${until(content, html`<span>Loading...</span>`)}`
+ * ```
+ */
+export const lazyUntil: (...values: any[]) => import("lit-html/directive.js").DirectiveResult<typeof UntilDirective>;
+import { AsyncDirective } from "lit-html/async-directive.js";
+declare class PseudoWeakRef {
+    constructor(ref: any);
+    _ref: any;
+    disconnect(): void;
+    reconnect(ref: any): void;
+    deref(): any;
+}
+declare class Pauser {
+    _promise: undefined;
+    _resolve: undefined;
+    get(): undefined;
+    pause(): void;
+    resume(): void;
+}
+export {};

package/dist/directives/lazy-until.js

@@ -0,0 +1,143 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+/* eslint-disable import/group-exports */
+import { noChange } from 'lit-html';
+import { directive } from 'lit-html/directive.js';
+import { isPrimitive } from 'lit-html/directive-helpers.js';
+import { AsyncDirective } from 'lit-html/async-directive.js';
+class PseudoWeakRef {
+    constructor(ref) {
+        this._ref = ref;
+    }
+    disconnect() {
+        this._ref = undefined;
+    }
+    reconnect(ref) {
+        this._ref = ref;
+    }
+    deref() {
+        return this._ref;
+    }
+}
+class Pauser {
+    _promise = undefined;
+    _resolve = undefined;
+    get() {
+        return this._promise;
+    }
+    pause() {
+        this._promise ??= new Promise((resolve) => (this._resolve = resolve));
+    }
+    resume() {
+        this._resolve?.();
+        this._promise = this._resolve = undefined;
+    }
+}
+const isPromise = (x) => {
+    return !isPrimitive(x) && typeof x.then === 'function';
+}, 
+// Effectively infinity, but a SMI.
+_infinity = 0x3fffffff;
+export class UntilDirective extends AsyncDirective {
+    __lastRenderedIndex = _infinity;
+    __values = [];
+    __weakThis = new PseudoWeakRef(this);
+    __pauser = new Pauser();
+    render(...args) {
+        return args.find((x) => !isPromise(x)) ?? noChange;
+    }
+    // eslint-disable-next-line max-statements
+    update(_part, args) {
+        const previousValues = this.__values, previousLength = previousValues.length;
+        this.__values = args;
+        const weakThis = this.__weakThis, pauser = this.__pauser;
+        // If our initial render occurs while disconnected, ensure that the pauser
+        // and weakThis are in the disconnected state
+        if (!this.isConnected) {
+            this.disconnected();
+        }
+        for (let i = 0; i < args.length; i++) {
+            // If we've rendered a higher-priority value already, stop.
+            if (i > this.__lastRenderedIndex) {
+                break;
+            }
+            const value = args[i];
+            // Render non-Promise values immediately
+            if (!isPromise(value)) {
+                this.__lastRenderedIndex = i;
+                // Since a lower-priority value will never overwrite a higher-priority
+                // synchronous value, we can stop processing now.
+                return value;
+            }
+            // If this is a Promise we've already handled, skip it.
+            if (i < previousLength && value === previousValues[i]) {
+                continue;
+            }
+            // Note, the callback avoids closing over `this` so that the directive
+            // can be gc'ed before the promise resolves; instead `this` is retrieved
+            // from `weakThis`, which can break the hard reference in the closure when
+            // the directive disconnects
+            Promise.resolve(value).then(async (result) => {
+                // If we're disconnected, wait until we're (maybe) reconnected
+                // The while loop here handles the case that the connection state
+                // thrashes, causing the pauser to resume and then get re-paused
+                while (pauser.get()) {
+                    await pauser.get();
+                }
+                // If the callback gets here and there is no `this`, it means that the
+                // directive has been disconnected and garbage collected and we don't
+                // need to do anything else
+                const _this = weakThis.deref();
+                if (_this !== undefined) {
+                    const index = _this.__values.indexOf(value);
+                    // If state.values doesn't contain the value, we've re-rendered without
+                    // the value, so don't render it. Then, only render if the value is
+                    // higher-priority than what's already been rendered.
+                    if (index > -1 && index <= _this.__lastRenderedIndex) {
+                        _this.__lastRenderedIndex = index;
+                        _this.setValue(result);
+                    }
+                }
+            });
+        }
+        return noChange;
+    }
+    disconnected() {
+        this.__weakThis.disconnect();
+        this.__pauser.pause();
+    }
+    reconnected() {
+        this.__weakThis.reconnect(this);
+        this.__pauser.resume();
+    }
+}
+/**
+ * Renders one of a series of values, including Promises, to a Part.
+ *
+ * Values are rendered in priority order, with the first argument having the
+ * highest priority and the last argument having the lowest priority. If a
+ * value is a Promise, low-priority values will be rendered until it resolves.
+ *
+ * The priority of values can be used to create placeholder content for async
+ * data. For example, a Promise with pending content can be the first,
+ * highest-priority, argument, and a non_promise loading indicator template can
+ * be used as the second, lower-priority, argument. The loading indicator will
+ * render immediately, and the primary content will render when the Promise
+ * resolves.
+ *
+ * Example:
+ *
+ * ```js
+ * const content = fetch('./content.txt').then(r => r.text());
+ * html`${until(content, html`<span>Loading...</span>`)}`
+ * ```
+ */
+export const lazyUntil = directive(UntilDirective);
+/**
+ * The type of the class that powers this directive. Necessary for naming the
+ * directive's return type.
+ */
+// export type {UntilDirective};

package/dist/directives/measure.d.ts

@@ -0,0 +1,9 @@
+export const measure: () => import("lit-html/directive.js").DirectiveResult<typeof MeasureDirective>;
+declare class MeasureDirective extends Directive {
+    render(): symbol;
+    update(part: any, [select, onMeasure]: [any, any]): symbol;
+    measure(element: any, select: any, onMeasure: any): symbol;
+    _observer: ResizeObserver | undefined;
+}
+import { Directive } from "lit-html/directive.js";
+export {};

package/dist/directives/measure.js

@@ -0,0 +1,23 @@
+import { nothing } from 'lit-html';
+import { Directive, directive } from 'lit-html/directive.js';
+import { array } from '../array';
+class MeasureDirective extends Directive {
+    render() {
+        return nothing;
+    }
+    update(part, [select, onMeasure]) {
+        this.measure(part.element, select, onMeasure);
+        return nothing;
+    }
+    measure(element, select, onMeasure) {
+        this._observer?.disconnect();
+        const elements = array(select(element)), observer = (this._observer = new ResizeObserver((entries) => {
+            onMeasure(entries
+                .sort((a, b) => elements.indexOf(a.target) - elements.indexOf(b.target))
+                .map((e) => e.contentRect));
+        }));
+        elements.forEach((el) => observer.observe(el));
+        return nothing;
+    }
+}
+export const measure = directive(MeasureDirective);

package/dist/directives/portal.d.ts

@@ -0,0 +1,12 @@
+export const portal: () => import("lit-html/directive").DirectiveResult<typeof PortalDirective>;
+declare class PortalDirective extends AsyncDirective {
+    render(): import("lit-html").TemplateResult<1>;
+    update(part: any, [content, outlet]: [any, (HTMLElement | undefined)?]): import("lit-html").TemplateResult<1>;
+    updateOutlet(outlet: any, content: any): void;
+    _outlet: any;
+    content: any;
+    clearOutlet(): void;
+    _op: any;
+}
+import { AsyncDirective } from "lit-html/async-directive.js";
+export {};

package/dist/directives/portal.js

@@ -0,0 +1,51 @@
+import { html, nothing, render } from 'lit-html';
+import { AsyncDirective, directive } from 'lit-html/async-directive.js';
+import { setChildPartValue, clearPart, removePart, } from 'lit-html/directive-helpers.js';
+const createMarker = () => document.createComment(''), ChildPart = render(nothing, new DocumentFragment()).constructor;
+/**
+ * Helper element with a customizable disconnect behavior.
+ */
+class DisconnectObserver extends HTMLElement {
+    disconnectedCallback() {
+        this.onDisconnect();
+    }
+}
+customElements.define('disconnect-observer', DisconnectObserver);
+class PortalDirective extends AsyncDirective {
+    render() {
+        return html `<disconnect-observer
+			.onDisconnect=${() => {
+            this.isConnected = false;
+            this.disconnected();
+        }}
+		></disconnect-observer>`;
+    }
+    update(part, [content, outlet = document.body]) {
+        this.updateOutlet(outlet, content);
+        return this.render();
+    }
+    updateOutlet(outlet, content) {
+        if (this._outlet !== outlet) {
+            this.clearOutlet();
+        }
+        this._outlet = outlet;
+        const part = (this._op ??= new ChildPart(outlet.appendChild(createMarker()), outlet.appendChild(createMarker())));
+        setChildPartValue(part, (this.content = content));
+    }
+    clearOutlet() {
+        const part = this._op;
+        if (!part) {
+            return;
+        }
+        clearPart(part);
+        removePart(part);
+        this._op = undefined;
+    }
+    disconnected() {
+        this.clearOutlet();
+    }
+    reconnected() {
+        this.updateOutlet(this._outlet, this._content);
+    }
+}
+export const portal = directive(PortalDirective);

package/dist/directives/spread-props.d.ts

@@ -0,0 +1,8 @@
+export const spreadProps: () => import("lit-html/directive.js").DirectiveResult<typeof SpreadPropsDirective>;
+declare class SpreadPropsDirective extends Directive {
+    render(): symbol;
+    update(part: any, [props]: [any]): symbol;
+    _props: any;
+}
+import { Directive } from "lit-html/directive.js";
+export {};

package/dist/directives/spread-props.js

@@ -0,0 +1,21 @@
+import { nothing } from 'lit-html';
+import { Directive, directive } from 'lit-html/directive.js';
+const undefs = (prev, obj) => {
+    if (!prev || !obj) {
+        return;
+    }
+    const keys = Object.keys(obj);
+    return Object.fromEntries(Object.keys(prev).flatMap((k) => (keys.includes(k) ? [] : [[k, undefined]])));
+};
+class SpreadPropsDirective extends Directive {
+    render() {
+        return nothing;
+    }
+    update(part, [props]) {
+        if (this._props !== props) {
+            Object.assign(part.element, undefs(this._props, props), (this._props = props));
+        }
+        return nothing;
+    }
+}
+export const spreadProps = directive(SpreadPropsDirective);

package/dist/elements/cz-icon.d.ts

@@ -0,0 +1,8 @@
+import { svg } from 'lit-html';
+interface Ico {
+    icon?: ReturnType<typeof svg>;
+    width?: number;
+    height?: number;
+}
+export declare const arrowDropDown: import("lit-html").TemplateResult<2>, cancel: import("lit-html").TemplateResult<2>, check: import("lit-html").TemplateResult<2>, clear: import("lit-html").TemplateResult<2>, warning: import("lit-html").TemplateResult<2>, undo: import("lit-html").TemplateResult<2>, edit: import("lit-html").TemplateResult<2>, rightArrow: import("lit-html").TemplateResult<2>, leftArrow: import("lit-html").TemplateResult<2>, download: import("lit-html").TemplateResult<2>, print: import("lit-html").TemplateResult<2>, renderIcon: ({ icon, width, height }?: Ico) => import("lit-html").TemplateResult<1>;
+export {};

package/dist/elements/cz-icon.js

@@ -0,0 +1,15 @@
+import { html, svg } from 'lit-html';
+import { ifDefined } from 'lit-html/directives/if-defined';
+import { component } from 'haunted';
+export const arrowDropDown = svg `<path d="M7 10l5 5 5-5z"></path>`, cancel = svg `<path d="M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm5 13.59L15.59 17 12 13.41 8.41 17 7 15.59 10.59 12 7 8.41 8.41 7 12 10.59 15.59 7 17 8.41 13.41 12 17 15.59z"></path>`, check = svg `<path d="M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41z"></path>`, clear = svg `<path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"></path>`, warning = svg `<path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z" fill="currentColor"></path>`, undo = svg `<path d="M12.5 8c-2.65 0-5.05.99-6.9 2.6L2 7v9h9l-3.62-3.62c1.39-1.16 3.16-1.88 5.12-1.88 3.54 0 6.55 2.31 7.6 5.5l2.37-.78C21.08 11.03 17.15 8 12.5 8z"></path>`, edit = svg `<path d="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"></path>`, rightArrow = svg `<path d="M12 4l-1.41 1.41L16.17 11H4v2h12.17l-5.58 5.59L12 20l8-8z" fill="currentColor"></path>`, leftArrow = svg `<path d="M20 11H7.83l5.59-5.59L12 4l-8 8 8 8 1.41-1.41L7.83 13H20v-2z" fill="currentColor"></path>`, download = svg `<path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z" fill="currentColor"></path>`, print = svg `<path d="M19 8H5c-1.66 0-3 1.34-3 3v6h4v4h12v-4h4v-6c0-1.66-1.34-3-3-3zm-3 11H8v-5h8v5zm3-7c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm-1-9H6v4h12V3z" fill="currentColor"></path>`, renderIcon = ({ icon, width = 24, height } = {}) => html `<svg
+		viewBox="0 0 24 24"
+		preserveAspectRatio="xMidYMid meet"
+		focusable="false"
+		width=${width}
+		height=${ifDefined(height)}
+	>
+		${icon}
+	</svg>`;
+customElements.define('cz-icon', component(renderIcon, {
+    observedAttributes: ['width', 'height'],
+}));

package/dist/elements/cz-spinner.d.ts

@@ -0,0 +1 @@
+export declare const Spinner: () => import("lit-html").TemplateResult<1>;

package/dist/elements/cz-spinner.js

@@ -0,0 +1,22 @@
+import { component, html } from 'haunted';
+export const Spinner = () => html `<style>
+	@keyframes rotating {
+		100% {
+			transform: rotate(360deg);
+		}
+	}
+
+	:host {
+		display: inline-block;
+		vertical-align: middle;
+		border-radius: 50%;
+		width: 22px;
+		height: 22px;
+		border: 2px solid rgba(0, 0, 0, 0.1);
+		border-top: 2px solid #5f5a92;
+		animation: rotating 1.2s infinite cubic-bezier(0.785, 0.135, 0.15, 0.86);
+		box-sizing: border-box;
+		margin: 0 4px;
+	}
+</style>`;
+customElements.define('cz-spinner', component(Spinner));

package/dist/elements/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cz-spinner';
+export * from './cz-icon';

package/dist/elements/index.js

@@ -0,0 +1,2 @@
+export * from './cz-spinner';
+export * from './cz-icon';

package/dist/function.d.ts

@@ -0,0 +1,5 @@
+declare type OrFn<T> = (...args: T[]) => boolean;
+declare type OnceFn<A, R> = (...args: A[]) => R;
+declare type OnceCheckFn<T> = (args: T[]) => boolean | undefined;
+export declare const constant: <T>(v?: T | undefined) => () => T | undefined, constTrue: () => boolean | undefined, constUndefined: () => unknown, noop: () => unknown, identity: <T>(obj: T) => T, or: <A, F extends OrFn<A>>(...fns: F[]) => (...args: A[]) => boolean, once: <A, R, F extends OnceFn<A, R>>(fn: F, check?: OnceCheckFn<A>) => (...args: A[]) => any;
+export {};

package/dist/function.js

@@ -0,0 +1,4 @@
+export const constant = (v) => () => v, constTrue = constant(true), constUndefined = constant(), noop = constUndefined, identity = (obj) => obj, or = (...fns) => (...args) => fns.reduce((res, fn) => res || fn(...args), false), once = (fn, check = constTrue) => {
+    let result;
+    return (...args) => (result ??= check(args) ? fn(...args) : undefined);
+};