@0djek/sveltix 0.0.6

package/dist/datagrid/modules/resize/components/ResizeHandle.svelte.d.ts

@@ -0,0 +1,28 @@
+export interface ResizeColumnOption {
+    enabled: boolean;
+}
+import type { HelperComponentProps } from '../../../core-modules/columns/Column.svelte';
+declare function $$render<T>(): {
+    props: HelperComponentProps<T, ResizeColumnOption>;
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const ResizeHandle: $$IsomorphicComponent;
+type ResizeHandle<T> = InstanceType<typeof ResizeHandle<T>>;
+export default ResizeHandle;

package/dist/datagrid/modules/resize/index.d.ts

@@ -0,0 +1,5 @@
+import { type ModuleRegistrationEntry } from '../..';
+import type { ResizeModuleOptions } from './models';
+export declare const RESIZE_MODULE: unique symbol;
+export declare function resizeModule<T>(options?: ResizeModuleOptions): ModuleRegistrationEntry<T, ResizeModuleOptions | undefined>;
+export * from './models';

package/dist/datagrid/modules/resize/index.js

@@ -0,0 +1,12 @@
+/// Module to allow users to resize columns by dragging and/or double clicking on the handle.
+import {} from '../..';
+import { ResizeModule } from './ResizeModule.svelte';
+export const RESIZE_MODULE = Symbol.for('RESIZE_MODULE');
+export function resizeModule(options) {
+    return {
+        key: RESIZE_MODULE,
+        module: (ResizeModule),
+        options: options,
+    };
+}
+export * from './models';

package/dist/datagrid/modules/resize/models/ResizeModuleOptions.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Options for the resize module.
+ */
+export interface ResizeModuleOptions {
+    /**
+     * Columns to enable. If empty or `undefined`, all columns are enabled.
+     *
+     * If defined, only these columns will have to the ability to be resized. If not defined, all columns are enabled.
+     */
+    idsEnable?: string[];
+    /**
+     * Columns to disable. If empty or `undefined`, no columns will be disabled.
+     */
+    idsDisable?: string[];
+}

package/dist/datagrid/modules/resize/models/ResizeModuleOptions.js

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

package/dist/datagrid/modules/resize/models/index.d.ts

@@ -0,0 +1 @@
+export * from './ResizeModuleOptions';

package/dist/datagrid/modules/resize/models/index.js

@@ -0,0 +1 @@
+export * from './ResizeModuleOptions';

package/dist/deep-equal/deepEqual.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Compares `first` and `second` and returns `true` if both are deeply equal, `false` otherwise.
+ * @param first First to check
+ * @param second Second to check
+ * @returns `true` if both are equal, `false` otherwise.
+ */
+export declare function deepEqual<T>(first: T | undefined, second: T | undefined): boolean;

package/dist/deep-equal/deepEqual.js

@@ -0,0 +1,79 @@
+/**
+ * Compares `first` and `second` and returns `true` if both are deeply equal, `false` otherwise.
+ * @param first First to check
+ * @param second Second to check
+ * @returns `true` if both are equal, `false` otherwise.
+ */
+export function deepEqual(first, second) {
+    if (first === second || (first == null && second == null)) {
+        return true;
+    }
+    if (first == null && second != null) {
+        return false;
+    }
+    if (first != null && second == null) {
+        return false;
+    }
+    if (typeof first !== 'object' && typeof second !== 'object') {
+        return first === second;
+    }
+    // Take care of possible arrays
+    const firstArray = Array.isArray(first);
+    const secondArray = Array.isArray(second);
+    if (firstArray && !secondArray) {
+        return false;
+    }
+    if (!firstArray && secondArray) {
+        return false;
+    }
+    if (firstArray && secondArray) {
+        return deepEqualBothArray(first, second);
+    }
+    // Take care of possible objects
+    const firstObject = typeof first === 'object';
+    const secondObject = typeof second === 'object';
+    if (firstObject && !secondObject) {
+        return false;
+    }
+    if (!firstObject && secondObject) {
+        return false;
+    }
+    return deepEqualNonNull(first, second);
+}
+function deepEqualBothArray(first, second) {
+    if (first.length !== second.length) {
+        return false;
+    }
+    // Iterate each entry and check.
+    for (let index = 0; index < first.length; index++) {
+        const result = deepEqual(first[index], second[index]);
+        if (!result) {
+            return false;
+        }
+    }
+    return true;
+}
+function deepEqualNonNull(first, second) {
+    const firstKeys = Object.keys(first);
+    const secondKeys = Object.keys(second);
+    // If both have no keys, objects are equal
+    if (firstKeys.length === 0 && secondKeys.length === 0) {
+        return true;
+    }
+    // If different number of keys, no need to check them individually.
+    if (firstKeys.length !== secondKeys.length) {
+        return false;
+    }
+    for (const firstKey of firstKeys) {
+        // Check if key exists in second object
+        if (second[firstKey] === undefined) {
+            return false;
+        }
+        // Compare entrie's values
+        const valuesEqual = deepEqual(first[firstKey], second[firstKey]);
+        if (!valuesEqual) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/deep-equal/index.d.ts

@@ -0,0 +1 @@
+export * from './deepEqual';

package/dist/deep-equal/index.js

@@ -0,0 +1 @@
+export * from './deepEqual';

package/dist/di/DiContainer.d.ts

@@ -0,0 +1,20 @@
+export declare enum Lifetime {
+    Scoped = "Scoped",
+    'Singleton' = "Singleton"
+}
+declare const TYPE: unique symbol;
+export interface InjectionKey<T> {
+    key: string;
+    constructor: new (...args: any[]) => T;
+    [TYPE]: T;
+    lifetime: Lifetime;
+    dependencies: InjectionKey<unknown>[];
+}
+export declare function createKey<T>(constructor: new (...args: any[]) => T): InjectionKey<T>;
+export declare class DiContainer {
+    private _dependencies;
+    registerScoped<T>(key: InjectionKey<T>): void;
+    registerSingleton<T>(key: InjectionKey<T>): void;
+    resolve<T>(key: InjectionKey<T>): T;
+}
+export {};

package/dist/di/DiContainer.js

@@ -0,0 +1,42 @@
+export var Lifetime;
+(function (Lifetime) {
+    Lifetime["Scoped"] = "Scoped";
+    Lifetime["Singleton"] = "Singleton";
+})(Lifetime || (Lifetime = {}));
+export function createKey(constructor) {
+    return {
+        constructor: constructor,
+        dependencies: [],
+        key: crypto.randomUUID(),
+    };
+}
+export class DiContainer {
+    _dependencies = new Map();
+    registerScoped(key) { }
+    registerSingleton(key) {
+        this._dependencies.set(key.key, {
+            instance: undefined,
+            key: key,
+            lifetime: Lifetime.Singleton,
+        });
+    }
+    resolve(key) {
+        const wanted = this._dependencies.get(key.key);
+        if (wanted == null) {
+            throw new Error(`Couldn't find service '${key.key}'`);
+        }
+        if (wanted.key.dependencies.length === 0) {
+            if (wanted.instance != null) {
+                return wanted.instance;
+            }
+            const instance = new wanted.key.constructor();
+            if (key.lifetime === Lifetime.Singleton) {
+                wanted.instance = instance;
+                this._dependencies.set(key.key, wanted);
+            }
+            return instance;
+        }
+        // const dependencies: unknown[] = [];
+        throw new Error('Not implemented');
+    }
+}

package/dist/event-bus/EventBus.d.ts

@@ -0,0 +1,9 @@
+import type { SubscriberSignature } from './models/SubscriberSignature';
+import type { UnsubscribeSignature } from './models/UnsubscribeSignature';
+import type { Event } from './models/Event';
+export declare class EventBus {
+    private _subscribers;
+    on<T>(event: Event<T>, callback: SubscriberSignature<T>): UnsubscribeSignature;
+    off(event: Event<unknown>, id: string): void;
+    emit<T>(event: Event<T>, data: T): void;
+}

package/dist/event-bus/EventBus.js

@@ -0,0 +1,38 @@
+export class EventBus {
+    _subscribers = new Map();
+    on(event, callback) {
+        const id = globalThis.crypto.randomUUID();
+        let eventSubscribers = this._subscribers.get(event.name);
+        if (eventSubscribers == null) {
+            eventSubscribers = [];
+        }
+        const casted = callback;
+        eventSubscribers.push({
+            id,
+            callback: casted,
+        });
+        this._subscribers.set(event.name, eventSubscribers);
+        return () => {
+            this.off(event, id);
+        };
+    }
+    off(event, id) {
+        let subscribers = this._subscribers.get(event.name);
+        if (subscribers == null || subscribers.length === 0) {
+            return;
+        }
+        subscribers = subscribers.filter((subcriber) => subcriber.id !== id);
+        if (subscribers.length === 0) {
+            this._subscribers.delete(event.name);
+            return;
+        }
+        this._subscribers.set(event.name, subscribers);
+    }
+    emit(event, data) {
+        const subscribers = this._subscribers.get(event.name);
+        if (subscribers == null || subscribers.length === 0) {
+            return;
+        }
+        subscribers.forEach((subscriber) => subscriber.callback(data));
+    }
+}

package/dist/event-bus/createEventDefinition.d.ts

@@ -0,0 +1 @@
+export declare function createEventDefinition<T>(name: string): Event<T>;

package/dist/event-bus/createEventDefinition.js

@@ -0,0 +1,5 @@
+export function createEventDefinition(name) {
+    return {
+        name,
+    };
+}

package/dist/event-bus/index.d.ts

@@ -0,0 +1,3 @@
+export * from './EventBus';
+export * from './createEventDefinition';
+export * from './models';

package/dist/event-bus/index.js

@@ -0,0 +1,3 @@
+export * from './EventBus';
+export * from './createEventDefinition';
+export * from './models';

package/dist/event-bus/models/Event.d.ts

@@ -0,0 +1,6 @@
+declare const EventType: unique symbol;
+export interface Event<T> {
+    name: string;
+    [EventType]: T;
+}
+export {};

package/dist/event-bus/models/Event.js

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

package/dist/event-bus/models/SubscriberEntry.d.ts

@@ -0,0 +1,5 @@
+import type { SubscriberSignature } from '../SubscriberSignature';
+export interface SubscriberEntry<T> {
+    id: string;
+    callback: SubscriberSignature<T>;
+}

package/dist/event-bus/models/SubscriberEntry.js

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

package/dist/event-bus/models/SubscriberSignature.d.ts

@@ -0,0 +1,3 @@
+export interface SubscriberSignature<T> {
+    (data: T): void;
+}

package/dist/event-bus/models/SubscriberSignature.js

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

package/dist/event-bus/models/UnsubscribeSignature.d.ts

@@ -0,0 +1,3 @@
+export interface UnsubscribeSignature {
+    (): void;
+}

package/dist/event-bus/models/UnsubscribeSignature.js

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

package/dist/event-bus/models/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Event';
+export * from './SubscriberEntry';
+export * from './SubscriberSignature';
+export * from './UnsubscribeSignature';

package/dist/event-bus/models/index.js

@@ -0,0 +1,4 @@
+export * from './Event';
+export * from './SubscriberEntry';
+export * from './SubscriberSignature';
+export * from './UnsubscribeSignature';

package/dist/groupBy/groupBy.d.ts

@@ -0,0 +1,2 @@
+import type { Grouping } from './models';
+export declare function groupBy<TKey, TValue>(entries: TValue[], group: (entry: TValue) => TKey): Grouping<TKey | undefined, TValue>[];

package/dist/groupBy/groupBy.js

@@ -0,0 +1,22 @@
+export function groupBy(entries, group) {
+    const groups = new Map();
+    entries.forEach((entry) => {
+        const key = group(entry);
+        const stringifiedKey = JSON.stringify(key);
+        const existing = groups.get(stringifiedKey) ?? [];
+        existing.push(entry);
+        groups.set(stringifiedKey, existing);
+    });
+    const groupings = [];
+    groups.forEach((value, key) => {
+        let parsedKey = undefined;
+        if (key != undefined) {
+            parsedKey = JSON.parse(key);
+        }
+        groupings.push({
+            key: parsedKey,
+            entries: value,
+        });
+    });
+    return groupings;
+}

package/dist/groupBy/index.d.ts

@@ -0,0 +1,2 @@
+export * from './groupBy';
+export * from './models';

package/dist/groupBy/index.js

@@ -0,0 +1,2 @@
+export * from './groupBy';
+export * from './models';

package/dist/groupBy/models/Grouping.d.ts

@@ -0,0 +1,4 @@
+export interface Grouping<TKey, TValue> {
+    key: TKey | undefined;
+    entries: TValue[];
+}

package/dist/groupBy/models/Grouping.js

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

package/dist/groupBy/models/index.d.ts

@@ -0,0 +1 @@
+export * from './Grouping';

package/dist/groupBy/models/index.js

@@ -0,0 +1 @@
+export * from './Grouping';

package/dist/heading/Heading.svelte

@@ -0,0 +1,28 @@
+<script lang="ts">
+	import { headingKey } from '.';
+	import { headingAlignClasses } from './headingClasses';
+	import { HeadingComponent } from './HeadingComponent.svelte';
+	import { Align } from './models/Align';
+	import type { HeadingProps } from './models/HeadingProps';
+
+	const props: HeadingProps = $props();
+
+	const heading = new HeadingComponent(() => props, headingKey);
+</script>
+
+<svelte:element
+	this={heading.getDom()}
+	class={[
+		heading.getStyles().getTag(heading.getTag()),
+		heading.getStyles().getTheme(heading.getTheme(), heading.getOnContainer()),
+		{
+			[headingAlignClasses.left]: heading.getAlign() === Align.Left,
+			[headingAlignClasses.center]: heading.getAlign() === Align.Center,
+			[headingAlignClasses.right]: heading.getAlign() === Align.Right,
+			[headingAlignClasses.justify]: heading.getAlign() === Align.Justify,
+			[headingAlignClasses.start]: heading.getAlign() === Align.Start,
+			[headingAlignClasses.end]: heading.getAlign() === Align.End,
+		},
+	]}>
+	{@render props.children?.()}
+</svelte:element>

package/dist/heading/Heading.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { HeadingProps } from './models/HeadingProps';
+declare const Heading: import("svelte").Component<HeadingProps, {}, "">;
+type Heading = ReturnType<typeof Heading>;
+export default Heading;

package/dist/heading/HeadingComponent.svelte.d.ts

@@ -0,0 +1,13 @@
+import { Component } from '../theme';
+import type { HeadingStyles } from './HeadingStyles';
+import { Align, type HeadingProps, type HeadingTag } from './models';
+export declare class HeadingComponent extends Component<HeadingStyles, HeadingProps> {
+    private _tag;
+    private _dom;
+    private _align;
+    private _onContainer;
+    getTag(): HeadingTag;
+    getDom(): string;
+    getAlign(): Align;
+    getOnContainer(): boolean;
+}

package/dist/heading/HeadingComponent.svelte.js

@@ -0,0 +1,20 @@
+import { Component } from '../theme';
+import { Align } from './models';
+export class HeadingComponent extends Component {
+    _tag = $derived.by(() => this._getProps().tag ?? 1);
+    _dom = $derived.by(() => this.getStyles().getDom(this._tag));
+    _align = $derived.by(() => this._getProps().align ?? Align.Left);
+    _onContainer = $derived.by(() => this._getProps().onContainer ?? false);
+    getTag() {
+        return this._tag;
+    }
+    getDom() {
+        return this._dom;
+    }
+    getAlign() {
+        return this._align;
+    }
+    getOnContainer() {
+        return this._onContainer;
+    }
+}

package/dist/heading/HeadingStyles.d.ts

@@ -0,0 +1,11 @@
+import type { Theme } from '../theme';
+import type { HeadingTag } from './models/HeadingTag';
+export interface HeadingStyles {
+    getBase(): string;
+    setBase(classes: string): void;
+    getTheme(theme: Theme, onContainer: boolean): string;
+    setTheme(theme: Theme, onContainer: boolean, classes: string): void;
+    getTag(tag: HeadingTag): string;
+    setTag(tag: HeadingTag, classes: string): void;
+    getDom(tag: HeadingTag): string;
+}

package/dist/heading/HeadingStyles.js

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

package/dist/heading/__tests__/HeadingBuilder.d.ts

@@ -0,0 +1,12 @@
+import type { Theme } from '../../theme';
+import type { Align, HeadingTag } from '../models';
+export declare class HeadingBuilder {
+    private _theme;
+    private _tag?;
+    private _align?;
+    static create(): HeadingBuilder;
+    withTheme(theme: Theme): HeadingBuilder;
+    withTag(tag: HeadingTag): HeadingBuilder;
+    withAlign(align: Align): HeadingBuilder;
+    build(): Promise<void>;
+}

package/dist/heading/__tests__/HeadingBuilder.js

@@ -0,0 +1,34 @@
+import { render } from 'vitest-browser-svelte';
+import PStory from './HeadingStory.svelte';
+import { DEFAULT_THEME } from '../../theme/themeDefaults';
+import HeadingStory from './HeadingStory.svelte';
+export class HeadingBuilder {
+    _theme = DEFAULT_THEME;
+    _tag;
+    _align;
+    static create() {
+        return new HeadingBuilder();
+    }
+    withTheme(theme) {
+        this._theme = theme;
+        return this;
+    }
+    withTag(tag) {
+        this._tag = tag;
+        return this;
+    }
+    withAlign(align) {
+        this._align = align;
+        return this;
+    }
+    async build() {
+        await render(HeadingStory, {
+            props: {
+                theme: this._theme,
+                message: 'test message',
+                align: this._align,
+                tag: this._tag,
+            },
+        });
+    }
+}

package/dist/heading/__tests__/HeadingStory.svelte

@@ -0,0 +1,16 @@
+<script lang="ts">
+	import type { Theme } from '../../theme';
+	import Heading from '../Heading.svelte';
+	import type { Align, HeadingTag } from '../models';
+
+	interface Props {
+		message: string;
+		theme?: Theme;
+		tag?: HeadingTag;
+	}
+	const { message, theme, tag }: Props = $props();
+</script>
+
+<Heading
+	{theme}
+	{tag}>{message}</Heading>

package/dist/heading/__tests__/HeadingStory.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { Theme } from '../../theme';
+import type { HeadingTag } from '../models';
+interface Props {
+    message: string;
+    theme?: Theme;
+    tag?: HeadingTag;
+}
+declare const HeadingStory: import("svelte").Component<Props, {}, "">;
+type HeadingStory = ReturnType<typeof HeadingStory>;
+export default HeadingStory;

package/dist/heading/headingClasses.d.ts

@@ -0,0 +1,8 @@
+export declare const headingAlignClasses: {
+    left: string;
+    center: string;
+    right: string;
+    justify: string;
+    start: string;
+    end: string;
+};

package/dist/heading/headingClasses.js

@@ -0,0 +1,8 @@
+export const headingAlignClasses = {
+    left: 'text-left',
+    center: 'text-center',
+    right: 'text-right',
+    justify: 'text-justify',
+    start: 'text-start',
+    end: 'text-end',
+};

package/dist/heading/index.d.ts

@@ -0,0 +1,5 @@
+import Heading from './Heading.svelte';
+import type { HeadingStyles } from './HeadingStyles';
+export { Heading };
+export * from './models';
+export declare const headingKey: import("../di/DiContainer").InjectionKey<HeadingStyles>;

package/dist/heading/index.js

@@ -0,0 +1,8 @@
+import { sveltix } from '..';
+import { createKey } from '../di/DiContainer';
+import Heading from './Heading.svelte';
+import { DefaultHeadingStyles } from './internal/DefaultHeadingStyles';
+export { Heading };
+export * from './models';
+export const headingKey = createKey(DefaultHeadingStyles);
+sveltix.registerSingleton(headingKey);

package/dist/heading/internal/DefaultHeadingStyles.d.ts

@@ -0,0 +1,15 @@
+import type { Theme } from '../../theme';
+import type { HeadingStyles } from '../HeadingStyles';
+import type { HeadingTag } from '../models/HeadingTag';
+export declare class DefaultHeadingStyles implements HeadingStyles {
+    private _base;
+    private _themes;
+    private _tags;
+    getBase(): string;
+    setBase(classes: string): void;
+    getTheme(theme: Theme, onContainer: boolean): string;
+    setTheme(theme: Theme, onContainer: boolean, classes: string): void;
+    getTag(tag: HeadingTag): string;
+    setTag(tag: HeadingTag, classes: string): void;
+    getDom(tag: HeadingTag): string;
+}