@box-kite/react 0.0.1 → 1.0.0

package/react-shared.mjs

@@ -0,0 +1,105 @@
+import e from "react";
+import { classNames as t, getDefaultEngine as n } from "@box-kite/core";
+//#region src/react/boxClassNames.ts
+function r({ classNames: e, styleElements: n }, r) {
+	return {
+		className: t(e, r).join(" "),
+		styles: n
+	};
+}
+//#endregion
+//#region src/utils/box/boxUtils.ts
+var i = { selected: "aria-selected" }, a;
+(function(e) {
+	function t(e, t, n) {
+		e !== void 0 && e != null && (n[i[t] ?? t] = Array.isArray(e) ? e[0] : e);
+	}
+	e.assignBooleanProp = t;
+})(a ||= {});
+var o = a;
+//#endregion
+//#region src/react/boxTagProps.ts
+function s(e, n) {
+	let r = e, { props: i, className: a, disabled: s, required: c, checked: l, selected: u } = r, d = {
+		...i,
+		className: t(n, a).join(" ")
+	};
+	return o.assignBooleanProp(s, "disabled", d), o.assignBooleanProp(c, "required", d), o.assignBooleanProp(l, "checked", d), o.assignBooleanProp(u, "selected", d), "style" in r && (d.style = r.style), "id" in r && (d.id = r.id), d;
+}
+//#endregion
+//#region src/react/styleElements.ts
+var c = parseInt(e.version, 10) >= 19, l = !1;
+function u(t) {
+	if (t?.length) return !c && !l && (l = !0, console.warn(`[box-kite] Box.configure({ sink: 'element' }) needs React 19 to hoist and dedupe its <style> elements; React ${e.version} will render them inline. Use the default sink instead.`)), t.map(({ href: t, css: n, precedence: r }) => e.createElement("style", {
+		key: t,
+		href: t,
+		precedence: r,
+		dangerouslySetInnerHTML: { __html: n }
+	}));
+}
+//#endregion
+//#region src/react/resolveStyles.ts
+function d(e, t) {
+	let { classNames: r, signature: i, styleElements: a } = n().resolveClassNames(e, t);
+	return {
+		classNames: r,
+		signature: i,
+		styleElements: u(a)
+	};
+}
+//#endregion
+//#region src/react/svg/attributesInProps.ts
+var f = "__boxAttributesInProps";
+function p(e) {
+	return e[f] = !0, e;
+}
+function m(e) {
+	return typeof e == "function" || typeof e == "object" && e ? e[f] === !0 : !1;
+}
+//#endregion
+//#region src/react/svg/svgNaming.ts
+var h = [
+	"role",
+	"aria-label",
+	"aria-labelledby",
+	"aria-hidden"
+];
+function g(e, t) {
+	if (e !== void 0) return {
+		role: "img",
+		"aria-label": e
+	};
+	if (!(t && h.some((e) => e in t))) return { "aria-hidden": !0 };
+}
+//#endregion
+//#region src/utils/string/stringUtils.ts
+var _;
+(function(e) {
+	function t(e) {
+		return e.charAt(0).toUpperCase() + e.slice(1);
+	}
+	e.capitalize = t;
+})(_ ||= {});
+var v = _, y;
+(function(e) {
+	function t(e, t, n) {
+		let r = { ...e }, i = r.props || {};
+		return t.forEach((e) => {
+			e in r && (i[e] = r[e], delete r[e]);
+		}), n && Object.entries(n).forEach(([e, t]) => {
+			i[e] = t;
+		}), r.props = i, r;
+	}
+	e.buildProps = t;
+	function n(e) {
+		return !!e && typeof e == "object";
+	}
+	e.isObject = n;
+	function r(e, t) {
+		return e in t;
+	}
+	e.isKeyOf = r;
+})(y ||= {});
+var b = y;
+//#endregion
+export { p as a, s as c, m as i, r as l, v as n, d as o, g as r, u as s, b as t };

package/rolldown-runtime.cjs

@@ -0,0 +1 @@
+var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,s)=>(s=n==null?{}:e(i(n)),o(r||!n||!n.__esModule||!a.call(n,`default`)?t(s,`default`,{value:n,enumerable:!0}):s,n));Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return s}});

package/rsc.cjs

@@ -0,0 +1 @@
+Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}});const e=require("./rolldown-runtime.cjs"),t=require("./react-shared.cjs");let n=require("react");n=e.t(n,1);let r=require("@box-kite/core");(0,r.getDefaultEngine)().configure({sink:`element`});function i(e){let{tag:r=`div`,children:i}=e;if(typeof i==`function`)throw Error(`[box-kite] Box children as a function track hover state, which needs the client Box — render it from a 'use client' module.`);let{classNames:a,styleElements:o}=t.o(e,r===`svg`);return n.default.createElement(n.default.Fragment,null,o,n.default.createElement(r,t.c(e,a),i))}var a=i;a.extend=r.BoxExtends.extend,a.components=r.BoxExtends.components,a.keyframes=r.BoxExtends.keyframes,a.spring=r.Springs.spring,a.getVariableValue=e=>(0,r.getDefaultEngine)().getVariableValue(e),a.configure=e=>(0,r.getDefaultEngine)().configure(e);function o(e,n){return t.l(t.o(e,n?.svg===!0),e.className)}exports.default=a,exports.useClassNames=o;

package/rsc.d.ts

@@ -0,0 +1,27 @@
+import { default as React } from 'react';
+import { BoxExtends, Springs, StylesConfiguration } from '@box-kite/core';
+import { BoxClassNames } from './react/boxClassNames';
+import { BoxClassNameProps, BoxCoreProps } from './react/boxProps';
+import { ComponentsAndVariants } from '@box-kite/core/types';
+interface RscBoxType {
+    <TTag extends keyof React.JSX.IntrinsicElements = 'div', TKey extends keyof ComponentsAndVariants = never>(props: BoxCoreProps<TTag, TKey>): React.ReactNode;
+    extend: typeof BoxExtends.extend;
+    components: typeof BoxExtends.components;
+    keyframes: typeof BoxExtends.keyframes;
+    /** A spring of your own, sampled into `{ easing, duration }`. Pure arithmetic, so a Server Component can call it. */
+    spring: typeof Springs.spring;
+    getVariableValue: (name: string) => string;
+    /** Explicit engine configuration. Element mode is already on; this is for the rest of it. */
+    configure: (config: StylesConfiguration) => void;
+}
+declare const RscBox: RscBoxType;
+/**
+ * The Server-Component half of `useClassNames` — see the client entry for what it is for. Not a hook
+ * here and it does not need to be, since resolving in element mode produces the `<style>` elements
+ * themselves. The `use` prefix stays so a component can move between the two entries unchanged.
+ */
+export declare function useClassNames<TKey extends keyof ComponentsAndVariants = never>(props: BoxClassNameProps<TKey>, options?: {
+    svg?: boolean;
+}): BoxClassNames;
+export default RscBox;
+export type { BoxClassNames, BoxClassNameProps };

package/rsc.mjs

@@ -0,0 +1,18 @@
+import { c as e, l as t, o as n } from "./react-shared.mjs";
+import r from "react";
+import { BoxExtends as i, Springs as a, getDefaultEngine as o } from "@box-kite/core";
+//#region src/rsc.ts
+o().configure({ sink: "element" });
+function s(t) {
+	let { tag: i = "div", children: a } = t;
+	if (typeof a == "function") throw Error("[box-kite] Box children as a function track hover state, which needs the client Box — render it from a 'use client' module.");
+	let { classNames: o, styleElements: s } = n(t, i === "svg");
+	return r.createElement(r.Fragment, null, s, r.createElement(i, e(t, o), a));
+}
+var c = s;
+c.extend = i.extend, c.components = i.components, c.keyframes = i.keyframes, c.spring = a.spring, c.getVariableValue = (e) => o().getVariableValue(e), c.configure = (e) => o().configure(e);
+function l(e, r) {
+	return t(n(e, r?.svg === !0), e.className);
+}
+//#endregion
+export { c as default, l as useClassNames };

package/ssg.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./rolldown-runtime.cjs"),t=require("./client.cjs");let n=require("react-dom/server");n=e.t(n,1);function r(){return t.r.getStyles()}function i(){t.r.clear()}function a(e,a=!0){let o=n.default.renderToStaticMarkup(e),s=r();if(a){let e=o.indexOf(`<head>`);if(e>-1){let n=e+6;o=o.substring(0,n)+`<style id="${t.r.styleElementId()}">${s}</style>`+o.substring(n)}}return i(),{html:o,styles:s}}exports.getStyles=r,exports.renderToStaticMarkup=a,exports.resetStyles=i;

package/ssg.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+/**
+ * Server rendering. There is no DOM here and the engine does not pretend there is one: with no
+ * `document` in the process it writes to an in-memory string sink, and `getStyles()` reads it back.
+ */
+/**
+ * The CSS for everything rendered since the last reset. Flushes first, so it is safe straight after
+ * `renderToString` — no effects have run at that point. Goes in a `<style id="box-kite-styles">` in the head.
+ */
+export declare function getStyles(): string;
+/**
+ * Drop every rule, class name and variable the engine has emitted, so the next request starts blank.
+ * Registration (`Box.extend()`, `Box.components()`) survives. Call it once per request, after `getStyles()`.
+ */
+export declare function resetStyles(): void;
+/**
+ * Render `element` to static HTML together with its CSS. With `addStylesToHead` (the default) and a
+ * `<head>` in the tree the styles go there; otherwise use the returned `styles`. The engine is reset
+ * before returning, so sequential calls are independent.
+ */
+export declare function renderToStaticMarkup(element: React.ReactElement, addStylesToHead?: boolean): {
+    html: string;
+    styles: string;
+};

package/ssg.mjs

@@ -0,0 +1,25 @@
+import { r as e } from "./client.mjs";
+import t from "react-dom/server";
+//#region src/ssg.ts
+function n() {
+	return e.getStyles();
+}
+function r() {
+	e.clear();
+}
+function i(i, a = !0) {
+	let o = t.renderToStaticMarkup(i), s = n();
+	if (a) {
+		let t = o.indexOf("<head>");
+		if (t > -1) {
+			let n = t + 6;
+			o = o.substring(0, n) + `<style id="${e.styleElementId()}">${s}</style>` + o.substring(n);
+		}
+	}
+	return r(), {
+		html: o,
+		styles: s
+	};
+}
+//#endregion
+export { n as getStyles, i as renderToStaticMarkup, r as resetStyles };

package/utils/animation/animationUtils.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The model behind `<Presence>`: how long the CSS already on an element says its current transition or
+ * animation lasts. No React and no DOM — it reads a `CSSStyleDeclaration`-shaped record, so CSS's
+ * list-cycling rules are testable without a browser, which is the only place they are ever exercised.
+ */
+declare namespace AnimationUtils {
+    /** The computed timing properties `activeDuration` reads. A `CSSStyleDeclaration` satisfies it. */
+    interface Timing {
+        transitionDuration: string;
+        transitionDelay: string;
+        animationName: string;
+        animationDuration: string;
+        animationDelay: string;
+        animationIterationCount: string;
+    }
+    /**
+     * One frame of head-room on a measured wait. The timer starts in the commit that applies the leaving
+     * styles, and the browser only creates the transition on the style recalculation after it — so the
+     * exit really ends a frame later than the duration alone says.
+     */
+    const SETTLE_FRAME = 16;
+    /**
+     * How long the element's own CSS says it has left to move, in ms. `0` means nothing is set up to run —
+     * which is also what `prefers-reduced-motion` produces, since every Box transition rides
+     * `--transitionTime` and that media query sets it to `0s`.
+     */
+    function activeDuration(timing: Timing): number;
+}
+export default AnimationUtils;

package/utils/array/arrayUtils.d.ts

@@ -0,0 +1,15 @@
+export type SortDirection = 'ASC' | 'DESC';
+export interface GroupItem<TKey, T> {
+    key: TKey;
+    values: T[];
+}
+declare namespace ArrayUtils {
+    function take<T>(items: readonly T[], count: number, skip?: number): T[];
+    function sumBy<T>(items: readonly T[], fn: (value: T, index: number) => number, initialValue?: number): number;
+    function sortBy<T, TVal>(items: readonly T[], fn: (value: T) => TVal, direction?: SortDirection): T[];
+    function maxBy<T>(items: readonly T[], fn: (value: T) => number): number;
+    function findOrThrow<T>(items: readonly T[], predicate: (value: T) => boolean): T;
+    function toRecord<T, K extends string | number | symbol, V>(items: readonly T[], fn: (value: T) => [K, V] | undefined): Record<K, V>;
+    function groupBy<T, TKey extends string | number | symbol>(items: readonly T[], keySelector: (item: T, index: number) => TKey): GroupItem<TKey, T>[];
+}
+export default ArrayUtils;

package/utils/box/boxUtils.d.ts

@@ -0,0 +1,5 @@
+import { BoxStylesWithPseudoClasses } from '@box-kite/core/types';
+declare namespace BoxUtils {
+    function assignBooleanProp<TProps>(prop: boolean | [boolean, BoxStylesWithPseudoClasses] | undefined, name: string, props: TProps): void;
+}
+export default BoxUtils;

package/utils/chart/chartUtils.d.ts

@@ -0,0 +1,98 @@
+/**
+ * The model behind the chart primitives: every number a `<Sparkline>`, `<ProgressRing>`, `<Gauge>` or
+ * `<MiniDonut>` draws with, the palette a `<ChartContainer>` declares, and no React. Components render,
+ * models decide — which is also what makes a path string testable with no DOM. Everything is measured
+ * in one square of `VIEW` user units.
+ */
+declare namespace ChartUtils {
+    /** The side of the square every primitive draws inside. */
+    const VIEW = 100;
+    /** The centre of that square, where a ring or a donut is centred. */
+    const CENTRE: number;
+    /**
+     * The step a ring fraction is rounded to. A dash length lands in a *class name*, so an unrounded
+     * fraction would mean a rule per value; half a percent of a 96px ring is a third of a pixel, and the
+     * arc can still transition. Data-driven *paths* need none of this — a `d` attribute generates no CSS.
+     */
+    const FRACTION_STEP = 0.005;
+    interface Point {
+        x: number;
+        y: number;
+    }
+    /** The ends of the value axis. Either can be fixed, so many rows can share one scale. */
+    interface Domain {
+        min?: number;
+        max?: number;
+    }
+    /** Rounded to `FRACTION_STEP` and clamped to the path: a ring cannot be more than full. */
+    function fraction(value: number): number;
+    /**
+     * The data as points in the view box, `y` already flipped for SVG's downward axis. Two decisions rather
+     * than guards: one datum is a flat line across the box, and data that never changes sits in the middle
+     * (`max === min` has no scale) instead of collapsing onto the floor.
+     */
+    function points(data: readonly number[], domain?: Domain): Point[];
+    /** The points as a polyline: `M x y L x y …`. */
+    function linePath(points: readonly Point[]): string;
+    /** The same line, closed down both sides to the floor of the box so it can be filled. */
+    function areaPath(points: readonly Point[]): string;
+    /**
+     * The data as bars in **one** path, because these are drawn fifty rows at a time inside a scrolling
+     * grid. `gap` is the share of each slot left empty; every bar keeps a floor of one unit, so a
+     * bottom-of-the-scale value reads as a mark on the axis rather than as missing data.
+     */
+    function barsPath(data: readonly number[], domain?: Domain, gap?: number): string;
+    /** The radius that fits a stroke of `thickness` inside the box, without clipping either edge. */
+    function radius(thickness: number): number;
+    /** The length of a full circle of that radius. */
+    function circumference(radius: number): number;
+    /**
+     * The dash pair that reveals `value` (0–1) of a path `length` long: one dash as long as the whole path,
+     * offset backwards, so the arc grows from its own beginning. Both are Box props, so it transitions.
+     */
+    function dash(length: number, value: number): {
+        strokeDasharray: number;
+        strokeDashoffset: number;
+    };
+    /** How long an arc of `sweep` degrees is — the path length a `dash` is measured against. */
+    function arcLength(radius: number, sweep: number): number;
+    /**
+     * An arc as a path, from `start` degrees clockwise through `sweep`. Only constants of the shape reach
+     * this, so it is the same string for every gauge alike and belongs in the `d` attribute. A full turn is
+     * split in half — one arc whose ends coincide draws nothing at all.
+     */
+    function arcPath(radius: number, start: number, sweep: number): string;
+    /** One segment of a donut: the dash that draws it, and how far round the circle it starts. */
+    interface Segment {
+        /** The visible run and the gap that follows it, as a `strokeDasharray` value. */
+        strokeDasharray: string;
+        /** Degrees clockwise from twelve o'clock — written as the `transform` attribute. */
+        rotate: number;
+        /** The datum this segment was drawn from, and its position in the data. */
+        value: number;
+        index: number;
+    }
+    /**
+     * One segment per value, each the share of the circle it is worth: the same circle dashed to its own
+     * length and turned by an *attribute*, so the angles generate no rules. Values summing to nothing give
+     * no segments rather than a division by zero, and a negative value counts as none.
+     */
+    function donutSegments(data: readonly number[], length: number): Segment[];
+    /**
+     * The colours a chart uses when nobody names any. Tokens rather than raw colours, so they resolve
+     * through the palette; six, because that is as many series as a tile can be told apart in — a seventh
+     * wraps round rather than inventing a colour.
+     */
+    const PALETTE: readonly ["sky-500", "emerald-500", "amber-500", "violet-500", "rose-500", "cyan-500"];
+    /** The same six for a dark background, where a 500 reads as muddy against near-black. */
+    const DARK_PALETTE: readonly ["sky-400", "emerald-400", "amber-400", "violet-400", "rose-400", "cyan-400"];
+    /** The numbered palette as custom properties: `{ 'chart-1': 'sky-500', … }`. */
+    function paletteVariables(palette: readonly string[]): Record<string, string>;
+    /**
+     * The variables a chart's series read, named as the ecosystem names them: `{ 'color-revenue':
+     * 'var(--chart-1)' }`. A list takes the palette in order, which is the whole case for the container — a
+     * chart naming no colour has its dark mode decided by the page. A record names its own paint per series.
+     */
+    function seriesVariables(series: readonly string[] | Readonly<Record<string, string>>, slots?: number): Record<string, string>;
+}
+export default ChartUtils;

package/utils/dom/domUtils.d.ts

@@ -0,0 +1,26 @@
+/**
+ * "Did this happen inside that?" — the question behind every popup that closes when you click away, asked
+ * identically by `useVisibility` and `useDismiss`. `ElementLike` is structural rather than
+ * `React.RefObject`, which keeps the file framework-free. Named exports rather than a namespace, for the
+ * reason in `environmentUtils.ts`: a namespace object cannot be tree-shaken a function at a time.
+ */
+export type ElementLike = {
+    readonly current: Element | null;
+} | Element | null | undefined;
+/** The element behind a ref or an element, whichever the caller happens to be holding. */
+export declare function elementOf(value: ElementLike): Element | null;
+/** The same, narrowed to an `HTMLElement` — for callers that need `focus()` or `style`. */
+export declare function htmlElementOf(value: ElementLike): HTMLElement | null;
+/**
+ * Whether an event happened inside any of these elements. `composedPath()` first, so an event from a
+ * shadow root counts as inside its host; `contains()` as the fallback, since the path is populated only
+ * while the event is being dispatched.
+ */
+export declare function isEventInside(event: Event, elements: readonly ElementLike[]): boolean;
+/**
+ * Whether this element reads right to left — the direction the browser *resolved*, which is the only
+ * form of the answer that accounts for a `dir="auto"` or a `<bdi>` above it. Nothing but
+ * `getComputedStyle` knows it, and jsdom computes no direction at all, so a test environment reads as
+ * left to right — which is the initial value anyway.
+ */
+export declare function isRtl(value: ElementLike): boolean;

package/utils/environment/environmentUtils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * "Is there a DOM, and what may I touch?" — asked in seven places and once answered with a hand-written
+ * `typeof` in each. The answers are not interchangeable: a server render has no `document`, a `document`
+ * may have no `<head>`, and `matchMedia` is missing from environments that look like browsers. Named
+ * exports rather than a namespace, which compiles to an IIFE that ships whole, and every chunk imports this.
+ */
+/** A browser: a window with a document. What an effect that touches layout needs to exist. */
+export declare function isBrowser(): boolean;
+/** Whether there is a document at all — false during a server render. */
+export declare function hasDocument(): boolean;
+/** The document, or null when there is none, so a caller can `?.` instead of branching. */
+export declare function documentOrNull(): Document | null;
+/** The document root (`<html>`), or null when there is no DOM. */
+export declare function documentRoot(): Element | null;
+/** The `<head>` to write a stylesheet into, or null when there is nothing to write to. */
+export declare function documentHead(): HTMLHeadElement | null;
+/** A media query, or null where `matchMedia` does not exist — a server, or a bare jsdom. */
+export declare function matchMedia(query: string): MediaQueryList | null;

package/utils/fn/fnUtils.d.ts

@@ -0,0 +1,4 @@
+declare namespace FnUtils {
+    function throttle<T extends unknown[]>(callback: (...args: T) => void, wait?: number): (...args: T) => void;
+}
+export default FnUtils;

package/utils/form/formUtils.d.ts

@@ -0,0 +1,8 @@
+type FormValue = string | string[] | number | number[] | boolean;
+interface FormObject {
+    [index: string]: FormValue | FormObject;
+}
+declare namespace FormUtils {
+    function getFormEntries(form: HTMLFormElement): FormObject;
+}
+export default FormUtils;

package/utils/memo.d.ts

@@ -0,0 +1,10 @@
+export interface Memo<T> {
+    value: T;
+    clear(): void;
+}
+/**
+ * Lazily-computed cached value with explicit dependency edges. Upstream memos go in `deps` as a thunk, so
+ * they can reference siblings whatever the declaration order; clearing a dep cascades, so a mutation only
+ * has to clear the root that changed.
+ */
+export default function memo<T>(action: () => T, deps?: () => Memo<unknown>[]): Memo<T>;

package/utils/object/objectUtils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Object helpers that know nothing about the prop registry — which is what lets both packages import
+ * this file. `mergeDeep` used to live here and does not any more: it reads `pseudo2`, so it belongs in
+ * `src/core/mergeDeep.ts` (see the note there).
+ */
+declare namespace ObjectUtils {
+    function buildProps<T extends {
+        props?: object;
+    }, TKey extends keyof T>(props: T, keys: Readonly<TKey[]>, extraTagProps?: object): T;
+    function isObject(value: unknown): value is object;
+    function isKeyOf<T extends object>(key: any, obj: T): key is keyof T;
+}
+export default ObjectUtils;

package/utils/string/fuzzySearch.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Fuzzy search implementation for text matching.
+ * Matches characters in order but not necessarily consecutively.
+ */
+export interface FuzzyMatch {
+    score: number;
+    matches: [number, number][];
+}
+/**
+ * Performs fuzzy matching of a pattern against a target string.
+ * Returns a match object with score and matched ranges, or null if no match.
+ */
+export declare function fuzzyMatch(pattern: string, target: string): FuzzyMatch | null;
+/**
+ * Simple fuzzy search that returns true if the pattern matches the target.
+ */
+export declare function fuzzySearch(pattern: string, target: string): boolean;
+/**
+ * Fuzzy search across multiple fields of an object.
+ * Returns true if the pattern matches any of the specified fields.
+ */
+export declare function fuzzySearchObject<T extends object>(pattern: string, obj: T, fields?: (keyof T)[]): boolean;
+/**
+ * Get the best fuzzy match score across multiple fields.
+ * Returns the highest score found, or 0 if no match.
+ */
+export declare function fuzzySearchObjectScore<T extends object>(pattern: string, obj: T, fields?: (keyof T)[]): number;

package/utils/string/stringUtils.d.ts

@@ -0,0 +1,4 @@
+declare namespace StringUtils {
+    function capitalize(str: string): string;
+}
+export default StringUtils;