@vitus-labs/core 1.2.2 → 1.2.3-alpha.3

package/lib/index.js

@@ -1,276 +1,432 @@
-export { get, merge, omit, pick, set, throttle } from 'lodash-es';
-export { default as memoize } from 'moize';
-import { ThemeProvider, styled, css } from 'styled-components';
-import React, { createContext, useMemo, isValidElement, createElement, cloneElement } from 'react';
-import { isFragment, isValidElementType } from 'react-is';
+import { ThemeProvider, css, styled } from "styled-components";
+import { cloneElement, createContext, createElement, isValidElement, useMemo } from "react";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { isFragment, isMemo, isValidElementType } from "react-is";
 
-class Configuration {
-    css;
-    styled;
-    ExternalProvider;
-    component = 'div';
-    textComponent = 'span';
-    constructor(props) {
-        this.css = props.css;
-        this.styled = props.styled;
-        this.ExternalProvider = props.provider;
-        this.component = props.component;
-        this.textComponent = props.textComponent;
-    }
-    init = (props) => {
-        if (props.css) {
-            this.css = props.css;
-        }
-        if (props.styled) {
-            this.styled = props.styled;
-        }
-        if (props.provider) {
-            this.ExternalProvider = props.provider;
-        }
-        if (props.component) {
-            this.component = props.component;
-        }
-        if (props.textComponent) {
-            this.textComponent = props.textComponent;
-        }
-    };
-}
-const defaultParams = {
-    css,
-    styled,
-    provider: ThemeProvider,
-    component: 'div',
-    textComponent: 'span',
+//#region src/compose.ts
+/**
+* Right-to-left function composition.
+* `compose(f, g, h)(x)` === `f(g(h(x)))`.
+*
+* Used throughout the system to build HOC chains —
+* `compose(attrsHoc, userHoc1, userHoc2)(Component)`.
+*/
+const compose = (...fns) => (p) => fns.reduceRight((acc, cur) => cur(acc), p);
+
+//#endregion
+//#region src/config.ts
+var Configuration = class {
+	css;
+	styled;
+	ExternalProvider;
+	component = "div";
+	textComponent = "span";
+	constructor(props) {
+		this.css = props.css;
+		this.styled = props.styled;
+		this.ExternalProvider = props.provider;
+		this.component = props.component;
+		this.textComponent = props.textComponent;
+	}
+	init = (props) => {
+		if (props.css) this.css = props.css;
+		if (props.styled) this.styled = props.styled;
+		if (props.provider) this.ExternalProvider = props.provider;
+		if (props.component) this.component = props.component;
+		if (props.textComponent) this.textComponent = props.textComponent;
+	};
 };
-const config = new Configuration(defaultParams);
+const config = new Configuration({
+	css,
+	styled,
+	provider: ThemeProvider,
+	component: "div",
+	textComponent: "span"
+});
 const { init } = config;
 
+//#endregion
+//#region src/isEmpty.ts
 const isEmpty = (param) => {
-    if (!param || param === null)
-        return true;
-    if (typeof param !== 'object') {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return true;
-    }
-    if (Array.isArray(param) && param.length === 0) {
-        return true;
-    }
-    if (Object.entries(param).length === 0 && param.constructor === Object) {
-        return true;
-    }
-    return false;
+	if (!param) return true;
+	if (typeof param !== "object") return true;
+	if (Array.isArray(param)) return param.length === 0;
+	return Object.keys(param).length === 0;
 };
 
+//#endregion
+//#region src/context.tsx
+/**
+* Internal React context shared across all @vitus-labs packages.
+* Carries the theme object plus any extra provider props.
+*/
 const context = createContext({});
 const VitusLabsProvider = context.Provider;
+/**
+* Dual-layer provider that feeds both the internal VitusLabs context
+* and an optional external styling provider (e.g. styled-components'
+* ThemeProvider). When no theme is supplied, renders children directly.
+*/
 const Provider = ({ theme, children, ...props }) => {
-    const ExternalProvider = useMemo(() => config.ExternalProvider, []);
-    const context = useMemo(() => ({ theme, ...props }), [theme, props]);
-    // eslint-disable-next-line react/jsx-no-useless-fragment
-    if (isEmpty(theme) || !theme)
-        return React.createElement(React.Fragment, null, children);
-    if (ExternalProvider) {
-        return (React.createElement(VitusLabsProvider, { value: context },
-            React.createElement(ExternalProvider, { theme: theme }, children)));
-    }
-    return React.createElement(VitusLabsProvider, { value: context }, children);
+	const ExternalProvider = useMemo(() => config.ExternalProvider, []);
+	const context = useMemo(() => ({
+		theme,
+		...props
+	}), [
+		theme,
+		...Object.values(props),
+		props
+	]);
+	if (isEmpty(theme) || !theme) return /* @__PURE__ */ jsx(Fragment, { children });
+	if (ExternalProvider) return /* @__PURE__ */ jsx(VitusLabsProvider, {
+		value: context,
+		children: /* @__PURE__ */ jsx(ExternalProvider, {
+			theme,
+			children
+		})
+	});
+	return /* @__PURE__ */ jsx(VitusLabsProvider, {
+		value: context,
+		children
+	});
 };
 
-const compose = (...fns) => (p) => 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
-fns.reduceRight((acc, cur) => cur(acc), p);
-
-const render = (content, attachProps) => {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    if (!content)
-        return null;
-    const isValidEl = isValidElement(content);
-    const render = (child) => attachProps ? createElement(child, attachProps) : createElement(child);
-    if (typeof content === 'string' && isValidEl) {
-        return render(content);
-    }
-    if (['number', 'boolean', 'bigint', 'string'].includes(typeof content)) {
-        return content;
-    }
-    if (Array.isArray(content) || isFragment(content)) {
-        return content;
-    }
-    if (isValidElementType(content)) {
-        return render(content);
-    }
-    if (isValidEl) {
-        if (isEmpty(attachProps)) {
-            return content;
-        }
-        return cloneElement(content, attachProps);
-    }
-    return content;
+//#endregion
+//#region src/hoistNonReactStatics.ts
+const REACT_STATICS = {
+	childContextTypes: true,
+	contextType: true,
+	contextTypes: true,
+	defaultProps: true,
+	displayName: true,
+	getDefaultProps: true,
+	getDerivedStateFromError: true,
+	getDerivedStateFromProps: true,
+	mixins: true,
+	propTypes: true,
+	type: true
+};
+const KNOWN_STATICS = {
+	name: true,
+	length: true,
+	prototype: true,
+	caller: true,
+	callee: true,
+	arguments: true,
+	arity: true
+};
+const FORWARD_REF_STATICS = {
+	$$typeof: true,
+	render: true,
+	defaultProps: true,
+	displayName: true,
+	propTypes: true
+};
+const MEMO_STATICS = {
+	$$typeof: true,
+	compare: true,
+	defaultProps: true,
+	displayName: true,
+	propTypes: true,
+	type: true
+};
+const TYPE_STATICS = {};
+TYPE_STATICS[Symbol.for("react.forward_ref")] = FORWARD_REF_STATICS;
+TYPE_STATICS[Symbol.for("react.memo")] = MEMO_STATICS;
+const getStatics = (component) => {
+	if (isMemo(component)) return MEMO_STATICS;
+	return TYPE_STATICS[component.$$typeof] || REACT_STATICS;
+};
+const hoistNonReactStatics = (target, source, excludeList) => {
+	if (typeof source === "string") return target;
+	const proto = Object.getPrototypeOf(source);
+	if (proto && proto !== Object.prototype) hoistNonReactStatics(target, proto, excludeList);
+	const keys = [...Object.getOwnPropertyNames(source), ...Object.getOwnPropertySymbols(source)];
+	const targetStatics = getStatics(target);
+	const sourceStatics = getStatics(source);
+	for (const key of keys) {
+		const k = key;
+		if (KNOWN_STATICS[k] || excludeList?.[k] || sourceStatics[k] || targetStatics[k]) continue;
+		const descriptor = Object.getOwnPropertyDescriptor(source, key);
+		if (descriptor) try {
+			Object.defineProperty(target, key, descriptor);
+		} catch {}
+	}
+	return target;
 };
 
+//#endregion
+//#region src/html/htmlTags.ts
 const HTML_TAGS = [
-    'a',
-    'abbr',
-    // 'acronym',
-    'address',
-    // 'applet',
-    'area',
-    'article',
-    'aside',
-    'audio',
-    'b',
-    // 'base',
-    // 'basefont',
-    'bdi',
-    'bdo',
-    'big',
-    'blockquote',
-    'body',
-    'br',
-    'button',
-    'canvas',
-    'caption',
-    // 'center',
-    'cite',
-    'code',
-    'col',
-    'colgroup',
-    'data',
-    'datalist',
-    'dd',
-    'del',
-    'details',
-    'dfn',
-    'dialog',
-    // 'dir',
-    'div',
-    'dl',
-    'dt',
-    'em',
-    'embed',
-    'fieldset',
-    'figcaption',
-    'figure',
-    // 'font',
-    'footer',
-    'form',
-    // 'frame',
-    // 'frameset',
-    'h1',
-    'h2',
-    'h3',
-    'h4',
-    'h5',
-    'h6',
-    // 'head',
-    'header',
-    'hr',
-    'html',
-    'i',
-    'iframe',
-    'img',
-    'input',
-    'ins',
-    'kbd',
-    'label',
-    'legend',
-    'li',
-    // 'link',
-    'main',
-    'map',
-    'mark',
-    // 'meta',
-    'meter',
-    'nav',
-    // 'noframes',
-    // 'noscript',
-    'object',
-    'ol',
-    'optgroup',
-    'option',
-    'output',
-    'p',
-    // 'param',
-    'picture',
-    'pre',
-    'progress',
-    'q',
-    'rp',
-    'rt',
-    'ruby',
-    's',
-    'samp',
-    // 'script',
-    'section',
-    'select',
-    'small',
-    'source',
-    'span',
-    // 'strike',
-    'strong',
-    // 'style',
-    'sub',
-    'summary',
-    'sup',
-    'svg',
-    'table',
-    'tbody',
-    'td',
-    'template',
-    'textarea',
-    'tfoot',
-    'th',
-    'thead',
-    'time',
-    // 'title',
-    'tr',
-    'track',
-    // 'tt',
-    'u',
-    'ul',
-    'var',
-    'video',
-    'wbr',
+	"a",
+	"abbr",
+	"address",
+	"area",
+	"article",
+	"aside",
+	"audio",
+	"b",
+	"bdi",
+	"bdo",
+	"big",
+	"blockquote",
+	"body",
+	"br",
+	"button",
+	"canvas",
+	"caption",
+	"cite",
+	"code",
+	"col",
+	"colgroup",
+	"data",
+	"datalist",
+	"dd",
+	"del",
+	"details",
+	"dfn",
+	"dialog",
+	"div",
+	"dl",
+	"dt",
+	"em",
+	"embed",
+	"fieldset",
+	"figcaption",
+	"figure",
+	"footer",
+	"form",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"header",
+	"hr",
+	"html",
+	"i",
+	"iframe",
+	"img",
+	"input",
+	"ins",
+	"kbd",
+	"label",
+	"legend",
+	"li",
+	"main",
+	"map",
+	"mark",
+	"meter",
+	"nav",
+	"object",
+	"ol",
+	"optgroup",
+	"option",
+	"output",
+	"p",
+	"picture",
+	"pre",
+	"progress",
+	"q",
+	"rp",
+	"rt",
+	"ruby",
+	"s",
+	"samp",
+	"section",
+	"select",
+	"small",
+	"source",
+	"span",
+	"strong",
+	"sub",
+	"summary",
+	"sup",
+	"svg",
+	"table",
+	"tbody",
+	"td",
+	"template",
+	"textarea",
+	"tfoot",
+	"th",
+	"thead",
+	"time",
+	"tr",
+	"track",
+	"u",
+	"ul",
+	"var",
+	"video",
+	"wbr"
 ];
 const HTML_TEXT_TAGS = [
-    'abbr',
-    'b',
-    'bdi',
-    'bdo',
-    'big',
-    'blockquote',
-    'cite',
-    'code',
-    'dl',
-    'dt',
-    'em',
-    'figcaption',
-    'h1',
-    'h2',
-    'h3',
-    'h4',
-    'h5',
-    'h6',
-    'i',
-    'ins',
-    'kbd',
-    'label',
-    'legend',
-    'li',
-    'p',
-    'pre',
-    'q',
-    'rp',
-    'rt',
-    's',
-    'small',
-    'span',
-    'strong',
-    'sub',
-    'summary',
-    'sup',
-    'time',
-    'u',
+	"abbr",
+	"b",
+	"bdi",
+	"bdo",
+	"big",
+	"blockquote",
+	"cite",
+	"code",
+	"del",
+	"div",
+	"dl",
+	"dt",
+	"em",
+	"figcaption",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"i",
+	"ins",
+	"kbd",
+	"label",
+	"legend",
+	"li",
+	"p",
+	"pre",
+	"q",
+	"rp",
+	"rt",
+	"s",
+	"small",
+	"span",
+	"strong",
+	"sub",
+	"summary",
+	"sup",
+	"time",
+	"u"
 ];
 
-export { HTML_TAGS, HTML_TEXT_TAGS, Provider, compose, config, context, init, isEmpty, render };
-//# sourceMappingURL=index.js.map
+//#endregion
+//#region src/render.ts
+const render = (content, attachProps) => {
+	if (!content) return null;
+	const render = (child) => attachProps ? createElement(child, attachProps) : createElement(child);
+	if ([
+		"number",
+		"boolean",
+		"bigint",
+		"string"
+	].includes(typeof content)) return content;
+	if (Array.isArray(content) || isFragment(content)) return content;
+	if (isValidElementType(content)) return render(content);
+	if (isValidElement(content)) {
+		if (isEmpty(attachProps)) return content;
+		return cloneElement(content, attachProps);
+	}
+	return content;
+};
+
+//#endregion
+//#region src/utils.ts
+const omit = (obj, keys) => {
+	if (obj == null) return {};
+	if (!keys || keys.length === 0) return { ...obj };
+	const result = {};
+	const keysSet = new Set(keys);
+	for (const key in obj) if (Object.hasOwn(obj, key) && !keysSet.has(key)) result[key] = obj[key];
+	return result;
+};
+const pick = (obj, keys) => {
+	if (obj == null) return {};
+	if (!keys || keys.length === 0) return { ...obj };
+	const result = {};
+	for (const key of keys) {
+		const k = key;
+		if (Object.hasOwn(obj, k)) result[k] = obj[k];
+	}
+	return result;
+};
+const PATH_RE = /[^.[\]]+/g;
+/** Split a dot/bracket path string into individual key tokens. */
+const parsePath = (path) => {
+	if (Array.isArray(path)) return path;
+	return path.match(PATH_RE) ?? [];
+};
+const get = (obj, path, defaultValue) => {
+	const keys = parsePath(path);
+	let result = obj;
+	for (const key of keys) {
+		if (result == null) return defaultValue;
+		result = result[key];
+	}
+	return result === void 0 ? defaultValue : result;
+};
+const UNSAFE_KEYS = new Set([
+	"__proto__",
+	"prototype",
+	"constructor"
+]);
+const set = (obj, path, value) => {
+	const keys = parsePath(path);
+	if (keys.some((k) => UNSAFE_KEYS.has(k))) return obj;
+	let current = obj;
+	for (let i = 0; i < keys.length - 1; i++) {
+		const key = keys[i];
+		const nextKey = keys[i + 1];
+		if (current[key] == null) current[key] = /^\d+$/.test(nextKey) ? [] : {};
+		current = current[key];
+	}
+	const lastKey = keys[keys.length - 1];
+	if (lastKey != null) current[lastKey] = value;
+	return obj;
+};
+const throttle = (fn, wait = 0) => {
+	let lastCallTime;
+	let timeoutId;
+	let lastArgs;
+	const throttled = (...args) => {
+		const now = Date.now();
+		if (lastCallTime === void 0 || now - lastCallTime >= wait) {
+			lastCallTime = now;
+			fn(...args);
+		} else {
+			lastArgs = args;
+			if (timeoutId === void 0) {
+				const remaining = wait - (now - lastCallTime);
+				timeoutId = setTimeout(() => {
+					lastCallTime = Date.now();
+					timeoutId = void 0;
+					if (lastArgs) {
+						fn(...lastArgs);
+						lastArgs = void 0;
+					}
+				}, remaining);
+			}
+		}
+	};
+	throttled.cancel = () => {
+		if (timeoutId !== void 0) {
+			clearTimeout(timeoutId);
+			timeoutId = void 0;
+		}
+		lastArgs = void 0;
+		lastCallTime = void 0;
+	};
+	return throttled;
+};
+const isPlainObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+const merge = (target, ...sources) => {
+	for (const source of sources) {
+		if (source == null) continue;
+		for (const key of Object.keys(source)) {
+			if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+			const targetVal = target[key];
+			const sourceVal = source[key];
+			if (isPlainObject(targetVal) && isPlainObject(sourceVal)) target[key] = merge({ ...targetVal }, sourceVal);
+			else target[key] = sourceVal;
+		}
+	}
+	return target;
+};
+
+//#endregion
+export { HTML_TAGS, HTML_TEXT_TAGS, Provider, compose, config, context, get, hoistNonReactStatics, init, isEmpty, merge, omit, pick, render, set, throttle };
+//# sourceMappingURL=index.js.map