tera-system-ui 0.0.1 → 0.0.3

package/dist/index.js

@@ -1,2 +1,13 @@
-"use strict";
-// Reexport your entry components here
+export { BrandLogo } from './components/brand-logo';
+export { Button } from './components/button';
+export { Combobox } from './components/combobox';
+export { Command } from './components/command';
+export { Dialog } from './components/dialog';
+export { Header } from './components/header';
+export { IconArrowBigRightFilled, IconBook, IconBookmarkPlus, IconCalculator, IconCheck, IconChevronDown, IconCopy, IconCopyCheckFilled, IconHamburger, IconLanguage, IconLoader2, IconMoon, IconPointFilled, IconSearch, IconSun, IconSwitchHorizontal, IconSwitchVertical, IconTransform, IconX } from './components/icons';
+export { Input } from './components/input';
+export { LanguagePickerButton } from './components/language-picker-button';
+export { LightDarkToggle } from './components/light-dark-toggle';
+export { Popover } from './components/popover';
+export { SideNavigation, SideNavigationLayout, toggleSideNavigation } from './components/side-navigation';
+export { TeraUiContext } from './components/tera-ui-context';

package/dist/internal/command-score.d.ts

@@ -0,0 +1 @@
+export declare function commandScore(string: string, abbreviation: string): number;

package/dist/internal/command-score.js

@@ -0,0 +1,119 @@
+// The scores are arranged so that a continuous match of characters will
+// result in a total score of 1.
+//
+// The best case, this character is a match, and either this is the start
+// of the string, or the previous character was also a match.
+const SCORE_CONTINUE_MATCH = 1, 
+// A new match at the start of a word scores better than a new match
+// elsewhere as it's more likely that the user will type the starts
+// of fragments.
+// NOTE: We score word jumps between spaces slightly higher than slashes, brackets
+// hyphens, etc.
+SCORE_SPACE_WORD_JUMP = 0.9, SCORE_NON_SPACE_WORD_JUMP = 0.8, 
+// Any other match isn't ideal, but we include it for completeness.
+SCORE_CHARACTER_JUMP = 0.17, 
+// If the user transposed two letters, it should be significantly penalized.
+//
+// i.e. "ouch" is more likely than "curtain" when "uc" is typed.
+SCORE_TRANSPOSITION = 0.1, 
+// The goodness of a match should decay slightly with each missing
+// character.
+//
+// i.e. "bad" is more likely than "bard" when "bd" is typed.
+//
+// This will not change the order of suggestions based on SCORE_* until
+// 100 characters are inserted between matches.
+PENALTY_SKIPPED = 0.999, 
+// The goodness of an exact-case match should be higher than a
+// case-insensitive match by a small amount.
+//
+// i.e. "HTML" is more likely than "haml" when "HM" is typed.
+//
+// This will not change the order of suggestions based on SCORE_* until
+// 1000 characters are inserted between matches.
+PENALTY_CASE_MISMATCH = 0.9999, 
+// If the word has more characters than the user typed, it should
+// be penalised slightly.
+//
+// i.e. "html" is more likely than "html5" if I type "html".
+//
+// However, it may well be the case that there's a sensible secondary
+// ordering (like alphabetical) that it makes sense to rely on when
+// there are many prefix matches, so we don't make the penalty increase
+// with the number of tokens.
+PENALTY_NOT_COMPLETE = 0.99;
+const IS_GAP_REGEXP = /[\\/_+.#"@[({&]/, COUNT_GAPS_REGEXP = /[\\/_+.#"@[({&]/g, IS_SPACE_REGEXP = /[\s-]/, COUNT_SPACE_REGEXP = /[\s-]/g;
+function commandScoreInner(string, abbreviation, lowerString, lowerAbbreviation, stringIndex, abbreviationIndex, memoizedResults) {
+    if (abbreviationIndex === abbreviation.length) {
+        if (stringIndex === string.length) {
+            return SCORE_CONTINUE_MATCH;
+        }
+        return PENALTY_NOT_COMPLETE;
+    }
+    const memoizeKey = `${stringIndex},${abbreviationIndex}`;
+    if (memoizedResults[memoizeKey] !== undefined) {
+        return memoizedResults[memoizeKey];
+    }
+    const abbreviationChar = lowerAbbreviation.charAt(abbreviationIndex);
+    let index = lowerString.indexOf(abbreviationChar, stringIndex);
+    let highScore = 0;
+    let score, transposedScore, wordBreaks, spaceBreaks;
+    while (index >= 0) {
+        score = commandScoreInner(string, abbreviation, lowerString, lowerAbbreviation, index + 1, abbreviationIndex + 1, memoizedResults);
+        if (score > highScore) {
+            if (index === stringIndex) {
+                score *= SCORE_CONTINUE_MATCH;
+            }
+            else if (IS_GAP_REGEXP.test(string.charAt(index - 1))) {
+                score *= SCORE_NON_SPACE_WORD_JUMP;
+                wordBreaks = string.slice(stringIndex, index - 1).match(COUNT_GAPS_REGEXP);
+                if (wordBreaks && stringIndex > 0) {
+                    score *= Math.pow(PENALTY_SKIPPED, wordBreaks.length);
+                }
+            }
+            else if (IS_SPACE_REGEXP.test(string.charAt(index - 1))) {
+                score *= SCORE_SPACE_WORD_JUMP;
+                spaceBreaks = string.slice(stringIndex, index - 1).match(COUNT_SPACE_REGEXP);
+                if (spaceBreaks && stringIndex > 0) {
+                    score *= Math.pow(PENALTY_SKIPPED, spaceBreaks.length);
+                }
+            }
+            else {
+                score *= SCORE_CHARACTER_JUMP;
+                if (stringIndex > 0) {
+                    score *= Math.pow(PENALTY_SKIPPED, index - stringIndex);
+                }
+            }
+            if (string.charAt(index) !== abbreviation.charAt(abbreviationIndex)) {
+                score *= PENALTY_CASE_MISMATCH;
+            }
+        }
+        if ((score < SCORE_TRANSPOSITION &&
+            lowerString.charAt(index - 1) === lowerAbbreviation.charAt(abbreviationIndex + 1)) ||
+            (lowerAbbreviation.charAt(abbreviationIndex + 1) ===
+                lowerAbbreviation.charAt(abbreviationIndex) && // allow duplicate letters. Ref #7428
+                lowerString.charAt(index - 1) !== lowerAbbreviation.charAt(abbreviationIndex))) {
+            transposedScore = commandScoreInner(string, abbreviation, lowerString, lowerAbbreviation, index + 1, abbreviationIndex + 2, memoizedResults);
+            if (transposedScore * SCORE_TRANSPOSITION > score) {
+                score = transposedScore * SCORE_TRANSPOSITION;
+            }
+        }
+        if (score > highScore) {
+            highScore = score;
+        }
+        index = lowerString.indexOf(abbreviationChar, index + 1);
+    }
+    memoizedResults[memoizeKey] = highScore;
+    return highScore;
+}
+function formatInput(string) {
+    // convert all valid space characters to space so they match each other
+    return string.toLowerCase().replace(COUNT_SPACE_REGEXP, ' ');
+}
+export function commandScore(string, abbreviation) {
+    /* NOTE:
+     * in the original, we used to do the lower-casing on each recursive call, but this meant that toLowerCase()
+     * was the dominating cost in the algorithm, passing both is a little ugly, but considerably faster.
+     */
+    return commandScoreInner(string, abbreviation, formatInput(string), formatInput(abbreviation), 0, 0, {});
+}

package/dist/internal/helpers/callbacks.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A callback function that takes an array of arguments of type `T` and returns `void`.
+ * @template T The types of the arguments that the callback function takes.
+ */
+export type Callback<T extends unknown[] = unknown[]> = (...args: T) => void;
+/**
+ * Executes an array of callback functions with the same arguments.
+ * @template T The types of the arguments that the callback functions take.
+ * @param n array of callback functions to execute.
+ * @returns A new function that executes all of the original callback functions with the same arguments.
+ */
+export declare function executeCallbacks<T extends unknown[]>(...callbacks: Array<Callback<T>>): (...args: T) => void;

package/dist/internal/helpers/callbacks.js

@@ -0,0 +1,15 @@
+/**
+ * Executes an array of callback functions with the same arguments.
+ * @template T The types of the arguments that the callback functions take.
+ * @param n array of callback functions to execute.
+ * @returns A new function that executes all of the original callback functions with the same arguments.
+ */
+export function executeCallbacks(...callbacks) {
+    return (...args) => {
+        for (const callback of callbacks) {
+            if (typeof callback === 'function') {
+                callback(...args);
+            }
+        }
+    };
+}

package/dist/internal/helpers/event.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A type alias for a general event listener function.
+ *
+ * @template E - The type of event to listen for
+ * @param evt - The event object
+ * @returns The return value of the event listener function
+ */
+export type GeneralEventListener<E = Event> = (evt: E) => unknown;
+/**
+ *  Overloaded function signatures for addEventListener
+ */
+export declare function addEventListener<E extends keyof HTMLElementEventMap>(target: Window, event: E, handler: (this: Window, ev: HTMLElementEventMap[E]) => unknown, options?: boolean | AddEventListenerOptions): VoidFunction;
+export declare function addEventListener<E extends keyof HTMLElementEventMap>(target: Document, event: E, handler: (this: Document, ev: HTMLElementEventMap[E]) => unknown, options?: boolean | AddEventListenerOptions): VoidFunction;
+export declare function addEventListener<E extends keyof HTMLElementEventMap>(target: EventTarget, event: E, handler: GeneralEventListener<HTMLElementEventMap[E]>, options?: boolean | AddEventListenerOptions): VoidFunction;

package/dist/internal/helpers/event.js

@@ -0,0 +1,17 @@
+/**
+ * Adds an event listener to the specified target element(s) for the given event(s), and returns a function to remove it.
+ * @param target The target element(s) to add the event listener to.
+ * @param event The event(s) to listen for.
+ * @param handler The function to be called when the event is triggered.
+ * @param options An optional object that specifies characteristics about the event listener.
+ * @returns A function that removes the event listener from the target element(s).
+ */
+export function addEventListener(target, event, handler, options) {
+    const events = Array.isArray(event) ? event : [event];
+    // Add the event listener to each specified event for the target element(s).
+    events.forEach((_event) => target.addEventListener(_event, handler, options));
+    // Return a function that removes the event listener from the target element(s).
+    return () => {
+        events.forEach((_event) => target.removeEventListener(_event, handler, options));
+    };
+}

package/dist/internal/helpers/id.d.ts

@@ -0,0 +1 @@
+export declare function generateId(): string;

package/dist/internal/helpers/id.js

@@ -0,0 +1,4 @@
+import { nanoid } from 'nanoid/non-secure';
+export function generateId() {
+    return nanoid(10);
+}

package/dist/internal/helpers/index.d.ts

@@ -0,0 +1,8 @@
+export * from './is.js';
+export * from './id.js';
+export * from './kbd.js';
+export * from './object.js';
+export * from './store.js';
+export * from './style.js';
+export * from './event.js';
+export * from './callbacks.js';

package/dist/internal/helpers/index.js

@@ -0,0 +1,8 @@
+export * from './is.js';
+export * from './id.js';
+export * from './kbd.js';
+export * from './object.js';
+export * from './store.js';
+export * from './style.js';
+export * from './event.js';
+export * from './callbacks.js';

package/dist/internal/helpers/is.d.ts

@@ -0,0 +1,4 @@
+export declare const isBrowser: boolean;
+export declare function isHTMLElement(element: unknown): element is HTMLElement;
+export declare function isHTMLInputElement(element: unknown): element is HTMLInputElement;
+export declare function isUndefined(value: unknown): value is undefined;

package/dist/internal/helpers/is.js

@@ -0,0 +1,10 @@
+export const isBrowser = typeof document !== 'undefined';
+export function isHTMLElement(element) {
+    return element instanceof HTMLElement;
+}
+export function isHTMLInputElement(element) {
+    return element instanceof HTMLInputElement;
+}
+export function isUndefined(value) {
+    return value === undefined;
+}

package/dist/internal/helpers/kbd.d.ts

@@ -0,0 +1,35 @@
+export declare const kbd: {
+    ALT: string;
+    ARROW_DOWN: string;
+    ARROW_LEFT: string;
+    ARROW_RIGHT: string;
+    ARROW_UP: string;
+    BACKSPACE: string;
+    CAPS_LOCK: string;
+    CONTROL: string;
+    DELETE: string;
+    END: string;
+    ENTER: string;
+    ESCAPE: string;
+    F1: string;
+    F10: string;
+    F11: string;
+    F12: string;
+    F2: string;
+    F3: string;
+    F4: string;
+    F5: string;
+    F6: string;
+    F7: string;
+    F8: string;
+    F9: string;
+    HOME: string;
+    META: string;
+    PAGE_DOWN: string;
+    PAGE_UP: string;
+    SHIFT: string;
+    SPACE: string;
+    TAB: string;
+    CTRL: string;
+    ASTERISK: string;
+};

package/dist/internal/helpers/kbd.js

@@ -0,0 +1,35 @@
+export const kbd = {
+    ALT: 'Alt',
+    ARROW_DOWN: 'ArrowDown',
+    ARROW_LEFT: 'ArrowLeft',
+    ARROW_RIGHT: 'ArrowRight',
+    ARROW_UP: 'ArrowUp',
+    BACKSPACE: 'Backspace',
+    CAPS_LOCK: 'CapsLock',
+    CONTROL: 'Control',
+    DELETE: 'Delete',
+    END: 'End',
+    ENTER: 'Enter',
+    ESCAPE: 'Escape',
+    F1: 'F1',
+    F10: 'F10',
+    F11: 'F11',
+    F12: 'F12',
+    F2: 'F2',
+    F3: 'F3',
+    F4: 'F4',
+    F5: 'F5',
+    F6: 'F6',
+    F7: 'F7',
+    F8: 'F8',
+    F9: 'F9',
+    HOME: 'Home',
+    META: 'Meta',
+    PAGE_DOWN: 'PageDown',
+    PAGE_UP: 'PageUp',
+    SHIFT: 'Shift',
+    SPACE: ' ',
+    TAB: 'Tab',
+    CTRL: 'Control',
+    ASTERISK: '*'
+};

package/dist/internal/helpers/object.d.ts

@@ -0,0 +1,2 @@
+export declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K>;
+export declare function removeUndefined<T extends object>(obj: T): T;

package/dist/internal/helpers/object.js

@@ -0,0 +1,19 @@
+export function omit(obj, ...keys) {
+    const result = {};
+    for (const key of Object.keys(obj)) {
+        if (!keys.includes(key)) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+}
+export function removeUndefined(obj) {
+    const result = {};
+    for (const key in obj) {
+        const value = obj[key];
+        if (value !== undefined) {
+            result[key] = value;
+        }
+    }
+    return result;
+}

package/dist/internal/helpers/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(ms: number): Promise<unknown>;

package/dist/internal/helpers/sleep.js

@@ -0,0 +1,3 @@
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/internal/helpers/store.d.ts

@@ -0,0 +1,29 @@
+import { type Writable, type Stores, type StoresValues, type Readable } from 'svelte/store';
+/**
+ * Given an object of properties, returns an object of writable stores
+ * with the same properties and values.
+ */
+export declare function toWritableStores<T extends Record<string, unknown>>(properties: T): {
+    [K in keyof T]: Writable<T[K]>;
+};
+/**
+ * A utility function that creates an effect from a set of stores and a function.
+ * The effect is automatically cleaned up when the component is destroyed.
+ *
+ * @template S - The type of the stores object
+ * @param stores - The stores object to derive from
+ * @param fn - The function to run when the stores change
+ * @returns A function that can be used to unsubscribe the effect
+ */
+export declare function effect<S extends Stores>(stores: S, fn: (values: StoresValues<S>) => (() => void) | void): () => void;
+/**
+ * A utility function that creates a derived store that automatically
+ * unsubscribes from its dependencies.
+ *
+ * @template S - The type of the stores object
+ * @template T - The type of the derived store
+ * @param stores - The stores object to derive from
+ * @param fn - The function to derive the store from
+ * @returns A derived store that automatically unsubscribes from its dependencies
+ */
+export declare function derivedWithUnsubscribe<S extends Stores, T>(stores: S, fn: (values: StoresValues<S>, onUnsubscribe: (cb: () => void) => void) => T): Readable<T>;

package/dist/internal/helpers/store.js

@@ -0,0 +1,80 @@
+import { derived, writable } from 'svelte/store';
+import { onDestroy } from 'svelte';
+/**
+ * Given an object of properties, returns an object of writable stores
+ * with the same properties and values.
+ */
+export function toWritableStores(properties) {
+    const result = {};
+    Object.keys(properties).forEach((key) => {
+        const propertyKey = key;
+        const value = properties[propertyKey];
+        result[propertyKey] = writable(value);
+    });
+    return result;
+}
+/**
+ * A utility function that creates an effect from a set of stores and a function.
+ * The effect is automatically cleaned up when the component is destroyed.
+ *
+ * @template S - The type of the stores object
+ * @param stores - The stores object to derive from
+ * @param fn - The function to run when the stores change
+ * @returns A function that can be used to unsubscribe the effect
+ */
+export function effect(stores, fn) {
+    // Create a derived store that contains the stores object and an onUnsubscribe function
+    const unsub = derivedWithUnsubscribe(stores, (stores, onUnsubscribe) => {
+        return {
+            stores,
+            onUnsubscribe
+        };
+    }).subscribe(({ stores, onUnsubscribe }) => {
+        const returned = fn(stores);
+        // If the function returns a cleanup function, call it when the effect is unsubscribed
+        if (returned) {
+            onUnsubscribe(returned);
+        }
+    });
+    // Automatically unsubscribe the effect when the component is destroyed
+    onDestroy(unsub);
+    return unsub;
+}
+/**
+ * A utility function that creates a derived store that automatically
+ * unsubscribes from its dependencies.
+ *
+ * @template S - The type of the stores object
+ * @template T - The type of the derived store
+ * @param stores - The stores object to derive from
+ * @param fn - The function to derive the store from
+ * @returns A derived store that automatically unsubscribes from its dependencies
+ */
+export function derivedWithUnsubscribe(stores, fn) {
+    let unsubscribers = [];
+    const onUnsubscribe = (cb) => {
+        unsubscribers.push(cb);
+    };
+    const unsubscribe = () => {
+        // Call all of the unsubscribe functions from the previous run of the function
+        unsubscribers.forEach((fn) => fn());
+        // Clear the list of unsubscribe functions
+        unsubscribers = [];
+    };
+    const derivedStore = derived(stores, ($storeValues) => {
+        unsubscribe();
+        return fn($storeValues, onUnsubscribe);
+    });
+    onDestroy(unsubscribe);
+    const subscribe = (...args) => {
+        const unsub = derivedStore.subscribe(...args);
+        return () => {
+            unsub();
+            unsubscribe();
+        };
+    };
+    return {
+        ...derivedStore,
+        subscribe
+    };
+}

package/dist/internal/helpers/style.d.ts

@@ -0,0 +1,12 @@
+export declare function styleToString(style: Record<string, number | string | undefined>): string;
+export declare const srOnlyStyles: {
+    position: string;
+    width: string;
+    height: string;
+    padding: string;
+    margin: string;
+    overflow: string;
+    clip: string;
+    whiteSpace: string;
+    borderWidth: string;
+};

package/dist/internal/helpers/style.js

@@ -0,0 +1,18 @@
+export function styleToString(style) {
+    return Object.keys(style).reduce((str, key) => {
+        if (style[key] === undefined)
+            return str;
+        return str + `${key}:${style[key]};`;
+    }, '');
+}
+export const srOnlyStyles = {
+    position: 'absolute',
+    width: '1px',
+    height: '1px',
+    padding: '0',
+    margin: '-1px',
+    overflow: 'hidden',
+    clip: 'rect(0, 0, 0, 0)',
+    whiteSpace: 'nowrap',
+    borderWidth: '0'
+};

package/dist/internal/index.d.ts

@@ -0,0 +1,3 @@
+export * from './command-score.js';
+export * from './helpers/index.js';
+export * from './types.js';

package/dist/internal/index.js

@@ -0,0 +1,3 @@
+export * from './command-score.js';
+export * from './helpers/index.js';
+export * from './types.js';

package/dist/internal/types.d.ts

@@ -0,0 +1,18 @@
+import type { HTMLAttributes } from 'svelte/elements';
+import type { TransitionConfig } from 'svelte/transition';
+export type Expand<T> = T extends object ? T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never : T;
+export type ValueOf<T> = T[keyof T];
+export type HTMLDivAttributes = HTMLAttributes<HTMLDivElement>;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type RenameProperties<T, NewNames extends Partial<Record<keyof T, string>>> = Expand<{
+    [K in keyof T as K extends keyof NewNames ? NewNames[K] extends PropertyKey ? NewNames[K] : K : K]: T[K];
+}>;
+export type PrefixKeys<T, Prefix extends string> = Expand<{
+    [K in keyof T as `${Prefix}${Capitalize<string & K>}`]: T[K];
+}>;
+export type Transition = (node: Element, params?: any) => TransitionConfig;
+export type Arrayable<T> = T | T[];

package/dist/internal/types.js

@@ -0,0 +1 @@
+export {};

package/dist/themes/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/themes/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/themes/scrollbar.scss

@@ -0,0 +1,37 @@
+/* Light mode scrollbar styles */
+::-webkit-scrollbar {
+  width: 8px;
+  height: 8px;
+}
+
+::-webkit-scrollbar-track {
+  background: transparent; /* Transparent track */
+}
+
+::-webkit-scrollbar-thumb {
+  background-color: rgba(0, 0, 0, 0.2); /* Light mode: dark thumb */
+  border-radius: 10px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background-color: rgba(0, 0, 0, 0.4); /* Darker thumb on hover */
+}
+
+/* Dark mode scrollbar styles */
+.dark ::-webkit-scrollbar-thumb {
+  background-color: rgba(255, 255, 255, 0.2); /* Dark mode: light thumb */
+}
+
+.dark ::-webkit-scrollbar-thumb:hover {
+  background-color: rgba(255, 255, 255, 0.4); /* Lighter thumb on hover */
+}
+
+/* Firefox scrollbar styling */
+* {
+  scrollbar-width: thin;
+  scrollbar-color: rgba(0, 0, 0, 0.2) transparent;
+}
+
+html.dark, .dark * {
+  scrollbar-color: rgba(255, 255, 255, 0.2) transparent;
+}