@emuanalytics/flow-rdf-core 0.0.15

package/dist/lib/utils/index.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+const stringUtils = require('../../shared/flow-rdf-core.3042be4a.cjs');
+const featureTypeChecks = require('../../shared/flow-rdf-core.84eded74.cjs');
+const functional = require('../../shared/flow-rdf-core.c44cf082.cjs');
+const lit = require('lit-html');
+require('@turf/invariant');
+
+
+
+exports.capitalize = stringUtils.capitalize;
+exports.ensureArray = stringUtils.ensureArray;
+exports.hasLength = stringUtils.hasLength;
+exports.hasValue = stringUtils.hasValue;
+exports.isArray = stringUtils.isArray;
+exports.isArrayFull = stringUtils.isArrayFull;
+exports.isArrayStrings = stringUtils.isArrayStrings;
+exports.isBoolean = stringUtils.isBoolean;
+exports.isDate = stringUtils.isDate;
+exports.isDefined = stringUtils.isDefined;
+exports.isFalse = stringUtils.isFalse;
+exports.isFunction = stringUtils.isFunction;
+exports.isIn = stringUtils.isIn;
+exports.isNil = stringUtils.isNil;
+exports.isNull = stringUtils.isNull;
+exports.isNumber = stringUtils.isNumber;
+exports.isNumeric = stringUtils.isNumeric;
+exports.isObject = stringUtils.isObject;
+exports.isObjectFull = stringUtils.isObjectFull;
+exports.isPlainObject = stringUtils.isPlainObject;
+exports.isString = stringUtils.isString;
+exports.isStringFull = stringUtils.isStringFull;
+exports.isTrue = stringUtils.isTrue;
+exports.isURL = stringUtils.isURL;
+exports.isUndefined = stringUtils.isUndefined;
+exports.isValue = stringUtils.isValue;
+exports.isLineString = featureTypeChecks.isLineString;
+exports.isMultiPolygon = featureTypeChecks.isMultiPolygon;
+exports.isPoint = featureTypeChecks.isPoint;
+exports.isPolygon = featureTypeChecks.isPolygon;
+exports.debounce = functional.debounce;
+exports.debounceWithArgs = functional.debounceWithArgs;
+exports.memoize = functional.memoize;
+exports.throttle = functional.throttle;
+exports.html = lit.html;

package/dist/lib/utils/index.d.cts

@@ -0,0 +1,39 @@
+import * as GeoJSON from 'geojson';
+export { d as debounce, a as debounceWithArgs, m as memoize, t as throttle } from '../../shared/flow-rdf-core.08975378.cjs';
+export { html } from 'lit-html';
+
+declare const isUndefined: (val: unknown) => val is undefined;
+declare const isNull: (val: unknown) => val is null;
+declare const isNil: (val: unknown) => val is null | undefined;
+declare const isDefined: <T>(val: T) => val is Exclude<T, null | undefined>;
+declare const isString: (val: unknown) => val is string;
+declare const hasLength: (val: unknown) => boolean;
+declare const isStringFull: (val: unknown) => val is string;
+declare const isArray: (val: unknown) => val is unknown[];
+declare const isArrayFull: (val: unknown) => val is unknown[];
+declare const isArrayStrings: (val: unknown) => val is string[];
+declare const isObject: (val: unknown) => val is object;
+declare const isObjectFull: (val: unknown) => boolean;
+declare const isNumber: (val: unknown) => val is number;
+declare const isFalse: (val: unknown) => val is false;
+declare const isTrue: (val: unknown) => val is true;
+declare const isIn: (val: unknown, arr: any[]) => boolean;
+declare const isBoolean: (val: unknown) => val is boolean;
+declare const isNumeric: (val: unknown) => boolean;
+declare const isDate: (val: unknown) => val is Date;
+declare const isValue: (val: unknown) => boolean;
+declare const hasValue: (val: unknown) => boolean;
+declare const isFunction: (val: unknown) => val is Function;
+declare function isPlainObject(o: unknown): boolean;
+declare function isURL(val: unknown): val is string;
+
+declare function ensureArray<T>(a: T | T[], ...rest: T[]): T[];
+
+declare const isPoint: (val: unknown) => val is GeoJSON.Point | GeoJSON.Feature<GeoJSON.Point, GeoJSON.GeoJsonProperties>;
+declare const isLineString: (val: any) => val is GeoJSON.LineString | GeoJSON.Feature<GeoJSON.LineString, GeoJSON.GeoJsonProperties>;
+declare const isPolygon: (val: any) => val is GeoJSON.Polygon | GeoJSON.Feature<GeoJSON.Polygon, GeoJSON.GeoJsonProperties>;
+declare const isMultiPolygon: (val: any) => val is GeoJSON.MultiPolygon | GeoJSON.Feature<GeoJSON.MultiPolygon, GeoJSON.GeoJsonProperties>;
+
+declare const capitalize: (str: string, lowerRest?: boolean) => string;
+
+export { capitalize, ensureArray, hasLength, hasValue, isArray, isArrayFull, isArrayStrings, isBoolean, isDate, isDefined, isFalse, isFunction, isIn, isLineString, isMultiPolygon, isNil, isNull, isNumber, isNumeric, isObject, isObjectFull, isPlainObject, isPoint, isPolygon, isString, isStringFull, isTrue, isURL, isUndefined, isValue };

package/dist/lib/utils/index.d.mts

@@ -0,0 +1,39 @@
+import * as GeoJSON from 'geojson';
+export { d as debounce, a as debounceWithArgs, m as memoize, t as throttle } from '../../shared/flow-rdf-core.08975378.mjs';
+export { html } from 'lit-html';
+
+declare const isUndefined: (val: unknown) => val is undefined;
+declare const isNull: (val: unknown) => val is null;
+declare const isNil: (val: unknown) => val is null | undefined;
+declare const isDefined: <T>(val: T) => val is Exclude<T, null | undefined>;
+declare const isString: (val: unknown) => val is string;
+declare const hasLength: (val: unknown) => boolean;
+declare const isStringFull: (val: unknown) => val is string;
+declare const isArray: (val: unknown) => val is unknown[];
+declare const isArrayFull: (val: unknown) => val is unknown[];
+declare const isArrayStrings: (val: unknown) => val is string[];
+declare const isObject: (val: unknown) => val is object;
+declare const isObjectFull: (val: unknown) => boolean;
+declare const isNumber: (val: unknown) => val is number;
+declare const isFalse: (val: unknown) => val is false;
+declare const isTrue: (val: unknown) => val is true;
+declare const isIn: (val: unknown, arr: any[]) => boolean;
+declare const isBoolean: (val: unknown) => val is boolean;
+declare const isNumeric: (val: unknown) => boolean;
+declare const isDate: (val: unknown) => val is Date;
+declare const isValue: (val: unknown) => boolean;
+declare const hasValue: (val: unknown) => boolean;
+declare const isFunction: (val: unknown) => val is Function;
+declare function isPlainObject(o: unknown): boolean;
+declare function isURL(val: unknown): val is string;
+
+declare function ensureArray<T>(a: T | T[], ...rest: T[]): T[];
+
+declare const isPoint: (val: unknown) => val is GeoJSON.Point | GeoJSON.Feature<GeoJSON.Point, GeoJSON.GeoJsonProperties>;
+declare const isLineString: (val: any) => val is GeoJSON.LineString | GeoJSON.Feature<GeoJSON.LineString, GeoJSON.GeoJsonProperties>;
+declare const isPolygon: (val: any) => val is GeoJSON.Polygon | GeoJSON.Feature<GeoJSON.Polygon, GeoJSON.GeoJsonProperties>;
+declare const isMultiPolygon: (val: any) => val is GeoJSON.MultiPolygon | GeoJSON.Feature<GeoJSON.MultiPolygon, GeoJSON.GeoJsonProperties>;
+
+declare const capitalize: (str: string, lowerRest?: boolean) => string;
+
+export { capitalize, ensureArray, hasLength, hasValue, isArray, isArrayFull, isArrayStrings, isBoolean, isDate, isDefined, isFalse, isFunction, isIn, isLineString, isMultiPolygon, isNil, isNull, isNumber, isNumeric, isObject, isObjectFull, isPlainObject, isPoint, isPolygon, isString, isStringFull, isTrue, isURL, isUndefined, isValue };

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

@@ -0,0 +1,39 @@
+import * as GeoJSON from 'geojson';
+export { d as debounce, a as debounceWithArgs, m as memoize, t as throttle } from '../../shared/flow-rdf-core.08975378.js';
+export { html } from 'lit-html';
+
+declare const isUndefined: (val: unknown) => val is undefined;
+declare const isNull: (val: unknown) => val is null;
+declare const isNil: (val: unknown) => val is null | undefined;
+declare const isDefined: <T>(val: T) => val is Exclude<T, null | undefined>;
+declare const isString: (val: unknown) => val is string;
+declare const hasLength: (val: unknown) => boolean;
+declare const isStringFull: (val: unknown) => val is string;
+declare const isArray: (val: unknown) => val is unknown[];
+declare const isArrayFull: (val: unknown) => val is unknown[];
+declare const isArrayStrings: (val: unknown) => val is string[];
+declare const isObject: (val: unknown) => val is object;
+declare const isObjectFull: (val: unknown) => boolean;
+declare const isNumber: (val: unknown) => val is number;
+declare const isFalse: (val: unknown) => val is false;
+declare const isTrue: (val: unknown) => val is true;
+declare const isIn: (val: unknown, arr: any[]) => boolean;
+declare const isBoolean: (val: unknown) => val is boolean;
+declare const isNumeric: (val: unknown) => boolean;
+declare const isDate: (val: unknown) => val is Date;
+declare const isValue: (val: unknown) => boolean;
+declare const hasValue: (val: unknown) => boolean;
+declare const isFunction: (val: unknown) => val is Function;
+declare function isPlainObject(o: unknown): boolean;
+declare function isURL(val: unknown): val is string;
+
+declare function ensureArray<T>(a: T | T[], ...rest: T[]): T[];
+
+declare const isPoint: (val: unknown) => val is GeoJSON.Point | GeoJSON.Feature<GeoJSON.Point, GeoJSON.GeoJsonProperties>;
+declare const isLineString: (val: any) => val is GeoJSON.LineString | GeoJSON.Feature<GeoJSON.LineString, GeoJSON.GeoJsonProperties>;
+declare const isPolygon: (val: any) => val is GeoJSON.Polygon | GeoJSON.Feature<GeoJSON.Polygon, GeoJSON.GeoJsonProperties>;
+declare const isMultiPolygon: (val: any) => val is GeoJSON.MultiPolygon | GeoJSON.Feature<GeoJSON.MultiPolygon, GeoJSON.GeoJsonProperties>;
+
+declare const capitalize: (str: string, lowerRest?: boolean) => string;
+
+export { capitalize, ensureArray, hasLength, hasValue, isArray, isArrayFull, isArrayStrings, isBoolean, isDate, isDefined, isFalse, isFunction, isIn, isLineString, isMultiPolygon, isNil, isNull, isNumber, isNumeric, isObject, isObjectFull, isPlainObject, isPoint, isPolygon, isString, isStringFull, isTrue, isURL, isUndefined, isValue };

package/dist/lib/utils/index.mjs

@@ -0,0 +1,5 @@
+export { c as capitalize, e as ensureArray, h as hasLength, w as hasValue, j as isArray, k as isArrayFull, l as isArrayStrings, s as isBoolean, u as isDate, d as isDefined, p as isFalse, x as isFunction, r as isIn, b as isNil, a as isNull, o as isNumber, t as isNumeric, m as isObject, n as isObjectFull, y as isPlainObject, f as isString, g as isStringFull, q as isTrue, z as isURL, i as isUndefined, v as isValue } from '../../shared/flow-rdf-core.b80085b4.mjs';
+export { i as isLineString, a as isMultiPolygon, b as isPoint, c as isPolygon } from '../../shared/flow-rdf-core.bd95d618.mjs';
+export { d as debounce, a as debounceWithArgs, m as memoize, t as throttle } from '../../shared/flow-rdf-core.2e456f93.mjs';
+export { html } from 'lit-html';
+import '@turf/invariant';

package/dist/shared/flow-rdf-core.08975378.d.cts

@@ -0,0 +1,68 @@
+/**
+ * Throttle execution of a function. Especially useful for rate limiting
+ * execution of handlers on events like resize and scroll.
+ *
+ * @param {number} delay -                  A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher)
+ *                                            are most useful.
+ * @param {Func} callback -               A function to be executed after delay milliseconds. The `this` context and all arguments are passed through,
+ *                                            as-is, to `callback` when the throttled-function is executed.
+ * @param {object} [options] -              An object to configure options.
+ * @param {boolean} [options.noTrailing] -   Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds
+ *                                            while the throttled-function is being called. If noTrailing is false or unspecified, callback will be executed
+ *                                            one final time after the last throttled-function call. (After the throttled-function has not been called for
+ *                                            `delay` milliseconds, the internal counter is reset).
+ * @param {boolean} [options.noLeading] -   Optional, defaults to false. If noLeading is false, the first throttled-function call will execute callback
+ *                                            immediately. If noLeading is true, the first the callback execution will be skipped. It should be noted that
+ *                                            callback will never executed if both noLeading = true and noTrailing = true.
+ * @param {boolean} [options.debounceMode] - If `debounceMode` is true (at begin), schedule `clear` to execute after `delay` ms. If `debounceMode` is
+ *                                            false (at end), schedule `callback` to execute after `delay` ms.
+ *
+ * @returns {Func} A new, throttled, function.
+ */
+type Func<TArgs extends any[] = any[], TResult = any | void> = (...args: TArgs) => TResult;
+type NoReturn<T extends Func> = Func<Parameters<T>, void>;
+interface CancelOptions {
+    upcomingOnly?: boolean;
+}
+interface Cancel {
+    cancel: (options?: CancelOptions) => void;
+}
+declare const doNotMemoize: unique symbol;
+interface MemoizeOptions<TArgs extends any[], TKey> {
+    hash?: Func<TArgs, TKey | typeof doNotMemoize>;
+    context?: any;
+}
+declare function memoize<TArgs extends any[], TResult, TKey>(originalFunction: Func<TArgs, TResult>, options: MemoizeOptions<TArgs, TKey>): (...args: TArgs) => TResult;
+interface ThrottleOptions {
+    delay: number;
+    noTrailing?: boolean;
+    noLeading?: boolean;
+    debounceMode?: boolean;
+    context?: any;
+}
+declare function throttle<T extends (...args: any[]) => any>(callback: T, options: ThrottleOptions): NoReturn<T> & Cancel;
+/**
+ * Debounce execution of a function. Debouncing, unlike throttling,
+ * guarantees that a function is only executed a single time, either at the
+ * very beginning of a series of calls, or at the very end.
+ *
+ * @param {number} delay -               A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
+ * @param {Func} callback -          A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,
+ *                                        to `callback` when the debounced-function is executed.
+ * @param {object} [options] -           An object to configure options.
+ * @param {boolean} [options.atBegin] -  Optional, defaults to false. If atBegin is false or unspecified, callback will only be executed `delay` milliseconds
+ *                                        after the last debounced-function call. If atBegin is true, callback will be executed only at the first debounced-function call.
+ *                                        (After the throttled-function has not been called for `delay` milliseconds, the internal counter is reset).
+ *
+ * @returns {Func} A new, debounced function.
+ */
+interface DebounceOptions {
+    delay: number;
+    atBegin?: boolean;
+    context?: any;
+}
+declare function debounce<T extends (...args: any[]) => any>(callback: T, options: DebounceOptions): NoReturn<T> & Cancel;
+type MemoizedDebounceOptions<TArgs extends any[], TKey> = DebounceOptions & MemoizeOptions<TArgs, TKey>;
+declare function debounceWithArgs<TArgs extends any[], TKey>(fn: Func<TArgs, any>, options: MemoizedDebounceOptions<TArgs, TKey>): Func<TArgs, void>;
+
+export { Func as F, debounceWithArgs as a, debounce as d, memoize as m, throttle as t };

package/dist/shared/flow-rdf-core.08975378.d.mts

@@ -0,0 +1,68 @@
+/**
+ * Throttle execution of a function. Especially useful for rate limiting
+ * execution of handlers on events like resize and scroll.
+ *
+ * @param {number} delay -                  A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher)
+ *                                            are most useful.
+ * @param {Func} callback -               A function to be executed after delay milliseconds. The `this` context and all arguments are passed through,
+ *                                            as-is, to `callback` when the throttled-function is executed.
+ * @param {object} [options] -              An object to configure options.
+ * @param {boolean} [options.noTrailing] -   Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds
+ *                                            while the throttled-function is being called. If noTrailing is false or unspecified, callback will be executed
+ *                                            one final time after the last throttled-function call. (After the throttled-function has not been called for
+ *                                            `delay` milliseconds, the internal counter is reset).
+ * @param {boolean} [options.noLeading] -   Optional, defaults to false. If noLeading is false, the first throttled-function call will execute callback
+ *                                            immediately. If noLeading is true, the first the callback execution will be skipped. It should be noted that
+ *                                            callback will never executed if both noLeading = true and noTrailing = true.
+ * @param {boolean} [options.debounceMode] - If `debounceMode` is true (at begin), schedule `clear` to execute after `delay` ms. If `debounceMode` is
+ *                                            false (at end), schedule `callback` to execute after `delay` ms.
+ *
+ * @returns {Func} A new, throttled, function.
+ */
+type Func<TArgs extends any[] = any[], TResult = any | void> = (...args: TArgs) => TResult;
+type NoReturn<T extends Func> = Func<Parameters<T>, void>;
+interface CancelOptions {
+    upcomingOnly?: boolean;
+}
+interface Cancel {
+    cancel: (options?: CancelOptions) => void;
+}
+declare const doNotMemoize: unique symbol;
+interface MemoizeOptions<TArgs extends any[], TKey> {
+    hash?: Func<TArgs, TKey | typeof doNotMemoize>;
+    context?: any;
+}
+declare function memoize<TArgs extends any[], TResult, TKey>(originalFunction: Func<TArgs, TResult>, options: MemoizeOptions<TArgs, TKey>): (...args: TArgs) => TResult;
+interface ThrottleOptions {
+    delay: number;
+    noTrailing?: boolean;
+    noLeading?: boolean;
+    debounceMode?: boolean;
+    context?: any;
+}
+declare function throttle<T extends (...args: any[]) => any>(callback: T, options: ThrottleOptions): NoReturn<T> & Cancel;
+/**
+ * Debounce execution of a function. Debouncing, unlike throttling,
+ * guarantees that a function is only executed a single time, either at the
+ * very beginning of a series of calls, or at the very end.
+ *
+ * @param {number} delay -               A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
+ * @param {Func} callback -          A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,
+ *                                        to `callback` when the debounced-function is executed.
+ * @param {object} [options] -           An object to configure options.
+ * @param {boolean} [options.atBegin] -  Optional, defaults to false. If atBegin is false or unspecified, callback will only be executed `delay` milliseconds
+ *                                        after the last debounced-function call. If atBegin is true, callback will be executed only at the first debounced-function call.
+ *                                        (After the throttled-function has not been called for `delay` milliseconds, the internal counter is reset).
+ *
+ * @returns {Func} A new, debounced function.
+ */
+interface DebounceOptions {
+    delay: number;
+    atBegin?: boolean;
+    context?: any;
+}
+declare function debounce<T extends (...args: any[]) => any>(callback: T, options: DebounceOptions): NoReturn<T> & Cancel;
+type MemoizedDebounceOptions<TArgs extends any[], TKey> = DebounceOptions & MemoizeOptions<TArgs, TKey>;
+declare function debounceWithArgs<TArgs extends any[], TKey>(fn: Func<TArgs, any>, options: MemoizedDebounceOptions<TArgs, TKey>): Func<TArgs, void>;
+
+export { Func as F, debounceWithArgs as a, debounce as d, memoize as m, throttle as t };

package/dist/shared/flow-rdf-core.08975378.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Throttle execution of a function. Especially useful for rate limiting
+ * execution of handlers on events like resize and scroll.
+ *
+ * @param {number} delay -                  A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher)
+ *                                            are most useful.
+ * @param {Func} callback -               A function to be executed after delay milliseconds. The `this` context and all arguments are passed through,
+ *                                            as-is, to `callback` when the throttled-function is executed.
+ * @param {object} [options] -              An object to configure options.
+ * @param {boolean} [options.noTrailing] -   Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds
+ *                                            while the throttled-function is being called. If noTrailing is false or unspecified, callback will be executed
+ *                                            one final time after the last throttled-function call. (After the throttled-function has not been called for
+ *                                            `delay` milliseconds, the internal counter is reset).
+ * @param {boolean} [options.noLeading] -   Optional, defaults to false. If noLeading is false, the first throttled-function call will execute callback
+ *                                            immediately. If noLeading is true, the first the callback execution will be skipped. It should be noted that
+ *                                            callback will never executed if both noLeading = true and noTrailing = true.
+ * @param {boolean} [options.debounceMode] - If `debounceMode` is true (at begin), schedule `clear` to execute after `delay` ms. If `debounceMode` is
+ *                                            false (at end), schedule `callback` to execute after `delay` ms.
+ *
+ * @returns {Func} A new, throttled, function.
+ */
+type Func<TArgs extends any[] = any[], TResult = any | void> = (...args: TArgs) => TResult;
+type NoReturn<T extends Func> = Func<Parameters<T>, void>;
+interface CancelOptions {
+    upcomingOnly?: boolean;
+}
+interface Cancel {
+    cancel: (options?: CancelOptions) => void;
+}
+declare const doNotMemoize: unique symbol;
+interface MemoizeOptions<TArgs extends any[], TKey> {
+    hash?: Func<TArgs, TKey | typeof doNotMemoize>;
+    context?: any;
+}
+declare function memoize<TArgs extends any[], TResult, TKey>(originalFunction: Func<TArgs, TResult>, options: MemoizeOptions<TArgs, TKey>): (...args: TArgs) => TResult;
+interface ThrottleOptions {
+    delay: number;
+    noTrailing?: boolean;
+    noLeading?: boolean;
+    debounceMode?: boolean;
+    context?: any;
+}
+declare function throttle<T extends (...args: any[]) => any>(callback: T, options: ThrottleOptions): NoReturn<T> & Cancel;
+/**
+ * Debounce execution of a function. Debouncing, unlike throttling,
+ * guarantees that a function is only executed a single time, either at the
+ * very beginning of a series of calls, or at the very end.
+ *
+ * @param {number} delay -               A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
+ * @param {Func} callback -          A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,
+ *                                        to `callback` when the debounced-function is executed.
+ * @param {object} [options] -           An object to configure options.
+ * @param {boolean} [options.atBegin] -  Optional, defaults to false. If atBegin is false or unspecified, callback will only be executed `delay` milliseconds
+ *                                        after the last debounced-function call. If atBegin is true, callback will be executed only at the first debounced-function call.
+ *                                        (After the throttled-function has not been called for `delay` milliseconds, the internal counter is reset).
+ *
+ * @returns {Func} A new, debounced function.
+ */
+interface DebounceOptions {
+    delay: number;
+    atBegin?: boolean;
+    context?: any;
+}
+declare function debounce<T extends (...args: any[]) => any>(callback: T, options: DebounceOptions): NoReturn<T> & Cancel;
+type MemoizedDebounceOptions<TArgs extends any[], TKey> = DebounceOptions & MemoizeOptions<TArgs, TKey>;
+declare function debounceWithArgs<TArgs extends any[], TKey>(fn: Func<TArgs, any>, options: MemoizedDebounceOptions<TArgs, TKey>): Func<TArgs, void>;
+
+export { Func as F, debounceWithArgs as a, debounce as d, memoize as m, throttle as t };