@nxgt/material-vue 0.1.0

package/dist/lib/lib/components/ui/upload/s3-upload-field/s3-upload-field.vue.d.ts

@@ -0,0 +1,8 @@
+import { S3UploadFieldProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<S3UploadFieldProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string | string[] | null | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<S3UploadFieldProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | string[] | null | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/lib/lib/components/ui/upload/s3-upload-field/types.d.ts

@@ -0,0 +1,19 @@
+import { HTMLAttributes } from 'vue';
+import { PresignedUploadTarget } from './s3-upload-field.utils';
+export type S3UploadFieldProps = {
+    label?: string;
+    helperText?: string;
+    error?: boolean;
+    disabled?: boolean;
+    accept?: string;
+    maxSize?: number;
+    maxFiles?: number;
+    onRemove?: (value: string) => void | Promise<void>;
+    onError?: (file: File, error: unknown) => void;
+    resolveUrl?: (value: string) => string | null | undefined;
+    name?: string;
+    class?: HTMLAttributes['class'];
+    mode: 'single' | 'multiple';
+    modelValue?: string | string[] | null;
+    getPresignedUrl: (file: File) => Promise<PresignedUploadTarget>;
+};

package/dist/lib/lib/components/ui/upload-field/index.d.ts

@@ -0,0 +1,2 @@
+export type { UploadFieldProps } from './upload-field.vue';
+export { default as UploadField } from './upload-field.vue';

package/dist/lib/lib/components/ui/upload-field/upload-field.vue.d.ts

@@ -0,0 +1,35 @@
+import { HTMLAttributes } from 'vue';
+export type UploadFieldProps = {
+    label?: string;
+    helperText?: string;
+    error?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    multiple?: boolean;
+    accept?: string;
+    name?: string;
+    id?: string;
+    placeholder?: string;
+    trailing?: string;
+    modelValue?: File | File[];
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_7: {}, __VLS_15: {};
+type __VLS_Slots = {} & {
+    leading?: (props: typeof __VLS_7) => any;
+} & {
+    trailing?: (props: typeof __VLS_15) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<UploadFieldProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: File | File[] | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<UploadFieldProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: File | File[] | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/lib/lib/components/ui/url-field/index.d.ts

@@ -0,0 +1,3 @@
+export { isUrl, normalizeUrl } from './parse-url';
+export type { UrlFieldProps } from './url-field.vue';
+export { default as UrlField } from './url-field.vue';

package/dist/lib/lib/components/ui/url-field/parse-url.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeUrl(raw: string): string | null;
+export declare function isUrl(raw: string): boolean;

package/dist/lib/lib/components/ui/url-field/url-field.vue.d.ts

@@ -0,0 +1,14 @@
+import { TextFieldProps } from '../text-field/text-field.vue';
+export type UrlFieldProps = Omit<TextFieldProps, 'type' | 'modelValue'> & {
+    modelValue?: string;
+    autocomplete?: string;
+};
+declare const __VLS_export: import('vue').DefineComponent<UrlFieldProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<UrlFieldProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    autocomplete: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/lib/lib/components/ui/video-player/index.d.ts

@@ -0,0 +1,2 @@
+/** @deprecated Use `StxPlayer` from `@nxgt/material-vue` instead. */
+export { StxPlayer as VideoPlayer, type StxPlayerProps as VideoPlayerProps, type StxTrack as VideoPlayerTrack, } from '../stx-player';

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

@@ -0,0 +1,10 @@
+export * from './resolve-theme';
+export * from './use-allowed-transitions';
+export * from './use-is-client';
+export * from './use-localized-date';
+export * from './use-mobile';
+export * from './use-navigation';
+export * from './use-number-formatter';
+export * from './use-options';
+export * from './use-search-param';
+export * from './use-theme';

package/dist/lib/lib/composables/resolve-theme.d.ts

@@ -0,0 +1,7 @@
+export type ThemePreference = 'light' | 'dark' | 'system';
+export type ResolvedTheme = 'light' | 'dark';
+export declare function resolveTheme(stored: string | undefined | null, prefersDark: boolean): {
+    theme: ResolvedTheme;
+    preference: ThemePreference;
+};
+export declare function applyResolvedTheme(theme: ResolvedTheme): void;

package/dist/lib/lib/composables/use-allowed-transitions.d.ts

@@ -0,0 +1,22 @@
+import { TranslationContext } from '../i18n';
+/**
+ * Locale key type is generic here (`TLocaleKey`) rather than tied to this
+ * package's own `MaterialLocaleKey`.
+ */
+export type TranslationConfig<TLocaleKey extends string = string> = TLocaleKey | {
+    key: TLocaleKey;
+    context: TranslationContext;
+};
+export type ActionMetadata<TStatus extends string, TLocaleKey extends string = string> = {
+    targetStatus: TStatus;
+    icon: string;
+    color?: string;
+    label: TLocaleKey;
+    dialogTitle: TLocaleKey;
+    dialogMessage: TranslationConfig<TLocaleKey>;
+};
+export type ActionConfig<TStatus extends string, TLocaleKey extends string = string> = Omit<ActionMetadata<TStatus, TLocaleKey>, 'targetStatus'>;
+/**
+ * Computes the allowed transitions from the current status.
+ */
+export declare function useAllowedTransitions<TStatus extends string, TLocaleKey extends string = string>(currentStatus: TStatus, allowedTransitions: Record<TStatus, TStatus[]>, configs: Partial<Record<TStatus, ActionConfig<TStatus, TLocaleKey>>>): ActionMetadata<TStatus, TLocaleKey>[];

package/dist/lib/lib/composables/use-is-client.d.ts

@@ -0,0 +1,2 @@
+/** SSR-hydration guard: `true` only after the component has mounted on the client. */
+export declare function useIsClient(): import('vue').Ref<boolean, boolean>;

package/dist/lib/lib/composables/use-localized-date.d.ts

@@ -0,0 +1,9 @@
+import { Locale } from 'date-fns';
+/**
+ * Date formatting bound to the current language.
+ */
+export declare function useLocalizedDate(): {
+    readonly language: "en" | "fr";
+    readonly locale: Locale;
+    format: (value?: string | null, formatStr?: string) => string;
+};

package/dist/lib/lib/composables/use-mobile.d.ts

@@ -0,0 +1 @@
+export declare function useIsMobile(): import('vue').ComputedRef<boolean>;

package/dist/lib/lib/composables/use-navigation.d.ts

@@ -0,0 +1,10 @@
+import { RouteLocationRaw } from 'vue-router';
+export declare function useNavigationHandler(to: RouteLocationRaw, options?: {
+    replace?: boolean;
+}): () => Promise<void | import('vue-router').NavigationFailure | undefined>;
+export declare function useNavigationHandlers(routes: {
+    to: RouteLocationRaw;
+    options?: {
+        replace?: boolean;
+    };
+}[]): (() => Promise<void | import('vue-router').NavigationFailure | undefined>)[];

package/dist/lib/lib/composables/use-number-formatter.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Number/currency formatting bound to the current language.
+ */
+export declare function useNumberFormatter(): {
+    formatCurrency: (value: number, options?: Omit<Intl.NumberFormatOptions, "language" | "style">) => string;
+    formatNumber: (value: number, options?: Omit<Intl.NumberFormatOptions, "language">) => string;
+};

package/dist/lib/lib/composables/use-options.d.ts

@@ -0,0 +1,28 @@
+import { ComputedRef } from 'vue';
+export type UseOptionsConfig<T extends object> = {
+    filter?: (item: T) => boolean;
+    value: keyof T | ((item: T) => string);
+    label: keyof T | (keyof T)[] | ((item: T) => string);
+    expanded?: boolean;
+};
+export type InferOptions<T extends object, Expanded extends boolean = false> = Expanded extends true ? (T & {
+    value: string;
+    label: string;
+})[] : {
+    value: string;
+    label: string;
+}[];
+export declare function buildOptions<T extends object, Expanded extends boolean = false>(items: T[], { filter, value, label, expanded }: UseOptionsConfig<T>): InferOptions<T, Expanded>;
+export declare function useOptions<T extends object, Expanded extends boolean = false>(items: T[], config: UseOptionsConfig<T>): ComputedRef<InferOptions<T, Expanded>>;
+/**
+ * Unwraps a GraphQL-edges shaped connection into a plain array of nodes.
+ */
+export declare function extractNode<T, E extends {
+    node: T;
+} = {
+    node: T;
+}, C extends {
+    edges: E[];
+} = {
+    edges: E[];
+}>(container?: C): T[];

package/dist/lib/lib/composables/use-search-param.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Read one URL search parameter via vue-router.
+ */
+export declare function useSearchParam(paramName: string): import('vue').ComputedRef<string | null>;

package/dist/lib/lib/composables/use-theme.d.ts

@@ -0,0 +1,7 @@
+import { ThemePreference } from './resolve-theme';
+export declare function useTheme(): {
+    readonly theme: import('./resolve-theme').ResolvedTheme;
+    readonly preference: ThemePreference;
+    updateTheme: (next: ThemePreference) => void;
+};
+export type { ResolvedTheme, ThemePreference } from './resolve-theme';

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

@@ -0,0 +1 @@
+export * from '../components/ui/dnd';

package/dist/lib/lib/i18n/consts.d.ts

@@ -0,0 +1,7 @@
+import { Language } from './types';
+/** `localStorage` key holding the user's selected language. */
+export declare const LANGUAGE_KEY = "language";
+/** Language used when nothing is stored, or the stored value is unsupported. */
+export declare const FALLBACK_LANGUAGE: Language;
+/** Languages the base bundle ships translations for. */
+export declare const SUPPORTED_LANGUAGES: Language[];

package/dist/lib/lib/i18n/i18n-provider.d.ts

@@ -0,0 +1,42 @@
+import { InjectionKey, PropType } from 'vue';
+import { I18nContextValue, Language } from './types';
+declare const I18nKey: InjectionKey<I18nContextValue>;
+export type I18nProviderProps = {
+    /** Language used when nothing valid is stored. Defaults to `'en'`. */
+    defaultLanguage?: Language;
+    /** `localStorage` key holding the selected language. Defaults to `'language'`. */
+    storageKey?: string;
+    /** Languages the app accepts. Defaults to the base bundle's languages. */
+    supportedLanguages?: Language[];
+    /** Notified after a successful language change (analytics, server sync...). */
+    onLanguageChange?: (language: Language) => void;
+    /**
+     * Language resolved by the host before first render — e.g. from a
+     * request's `Accept-Language` header or a locale cookie during SSR.
+     */
+    initialLanguage?: Language;
+};
+/**
+ * Call in the app root setup (or a dedicated provider component) so every
+ * consumer shares one language ref. Do not re-introduce a per-call-site
+ * language store — that is the bug that forced `window.location.reload()`.
+ */
+export declare function provideI18n(options?: I18nProviderProps): I18nContextValue;
+export declare function useI18nContext(): I18nContextValue;
+export declare function useOptionalI18nContext(): I18nContextValue | null;
+export declare const I18nProvider: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    defaultLanguage: PropType<Language>;
+    storageKey: StringConstructor;
+    supportedLanguages: PropType<Language[]>;
+    initialLanguage: PropType<Language>;
+    onLanguageChange: PropType<(language: Language) => void>;
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    defaultLanguage: PropType<Language>;
+    storageKey: StringConstructor;
+    supportedLanguages: PropType<Language[]>;
+    initialLanguage: PropType<Language>;
+    onLanguageChange: PropType<(language: Language) => void>;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export { I18nKey };

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

@@ -0,0 +1,8 @@
+export * from './consts';
+export * from './i18n-provider';
+export * from './merge-resources';
+export * from './resources';
+export * from './translator';
+export * from './types';
+export * from './use-material-translation';
+export * from './use-typed-translation';

package/dist/lib/lib/i18n/merge-resources.d.ts

@@ -0,0 +1,40 @@
+/** A resource bundle: language code -> top-level namespaces. */
+export type ResourceBundle = Record<string, Record<string, unknown>>;
+/**
+ * Per-language intersection of a base bundle and an app bundle, so callers keep
+ * full key inference over the merged shape:
+ *
+ * ```ts
+ * const resources = mergeResources(materialResources, appResources);
+ * type LocaleKey = keyof FlatObject<typeof resources.en, string>;
+ * ```
+ */
+export type MergedResources<TBase extends ResourceBundle, TApp extends ResourceBundle> = {
+    [L in keyof TBase | keyof TApp]: (L extends keyof TBase ? TBase[L] : unknown) & (L extends keyof TApp ? TApp[L] : unknown);
+};
+/**
+ * Deep-merges the base bundle shipped by `@nxgt/material-vue` with an app's own
+ * resources, per language.
+ *
+ * For each language present in either bundle, the two language objects are
+ * merged recursively (`lodash.merge`), so namespaces are combined at every
+ * depth: keys unique to either side are kept, and where both sides define the
+ * same leaf key the app's value wins.
+ *
+ * `@nxgt/material-vue` ships everything under a single top-level namespace per
+ * language — **`material`** (`resources.en.material.table.*`,
+ * `resources.en.material['empty-state'].*`, ...). Apps can override individual
+ * strings within it (e.g. just `material.command.title`) without losing the
+ * rest of the namespace. In development, any leaf-level override is reported
+ * through `console.warn` so it stays visible rather than silent.
+ *
+ * @example
+ * ```ts
+ * import { mergeResources, resources as materialResources } from '@nxgt/material-vue/i18n';
+ * import { resources as appResources } from './resources';
+ *
+ * export const resources = mergeResources(materialResources, appResources);
+ * export type LocaleKey = keyof FlatObject<typeof resources.en, string>;
+ * ```
+ */
+export declare function mergeResources<TBase extends ResourceBundle, TApp extends ResourceBundle>(base: TBase, app: TApp): MergedResources<TBase, TApp>;