@feugene/granularity 0.3.2 → 0.4.0

package/dist/types/src/components/GrTooltip/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from './GrTooltip.vue';
+export { default as GrTooltip } from './GrTooltip.vue';
+export type { GrTooltipProps } from './GrTooltip.vue';
+export { grTooltipConfig } from './config';

package/dist/types/src/components/{DsTree/DsTree.vue.d.ts → GrTree/GrTree.vue.d.ts}

@@ -1,27 +1,27 @@
-import type { DsTreeInstance, DsTreeNode, DsTreeNodeDropType } from './dsTreeTypes';
-import type { DsTreeProps } from './dsTreeProps';
+import type { GrTreeInstance, GrTreeNode, GrTreeNodeDropType } from './grTreeTypes';
+import type { GrTreeProps } from './grTreeProps';
 declare const __VLS_export: <T extends Record<string, any> = any>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & __VLS_PrettifyLocal<DsTreeProps<T> & {
-        onNodeClick?: ((data: T, node: DsTreeNode<T>) => any) | undefined;
-        onNodeExpand?: ((data: T, node: DsTreeNode<T>) => any) | undefined;
-        onNodeCollapse?: ((data: T, node: DsTreeNode<T>) => any) | undefined;
-        onNodeDrop?: ((draggingNode: DsTreeNode<T>, dropNode: DsTreeNode<T>, dropType: DsTreeNodeDropType) => any) | undefined;
+    props: import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & __VLS_PrettifyLocal<GrTreeProps<T> & {
+        onNodeClick?: ((data: T, node: GrTreeNode<T>) => any) | undefined;
+        onNodeExpand?: ((data: T, node: GrTreeNode<T>) => any) | undefined;
+        onNodeCollapse?: ((data: T, node: GrTreeNode<T>) => any) | undefined;
+        onNodeDrop?: ((draggingNode: GrTreeNode<T>, dropNode: GrTreeNode<T>, dropType: GrTreeNodeDropType) => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
-    expose: (exposed: import("vue").ShallowUnwrapRef<DsTreeInstance<T>>) => void;
+    expose: (exposed: import("vue").ShallowUnwrapRef<GrTreeInstance<T>>) => void;
     attrs: any;
     slots: {
         default?: (props: {
-            node: DsTreeNode<T>;
+            node: GrTreeNode<T>;
             data: T;
         }) => any;
     };
     emit: {
-        (event: "nodeClick", data: T, node: DsTreeNode<T>): void;
-        (event: "nodeExpand", data: T, node: DsTreeNode<T>): void;
-        (event: "nodeCollapse", data: T, node: DsTreeNode<T>): void;
-        (event: "nodeDrop", draggingNode: DsTreeNode<T>, dropNode: DsTreeNode<T>, dropType: DsTreeNodeDropType): void;
+        (event: "nodeClick", data: T, node: GrTreeNode<T>): void;
+        (event: "nodeExpand", data: T, node: GrTreeNode<T>): void;
+        (event: "nodeCollapse", data: T, node: GrTreeNode<T>): void;
+        (event: "nodeDrop", draggingNode: GrTreeNode<T>, dropNode: GrTreeNode<T>, dropType: GrTreeNodeDropType): void;
     };
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;

package/dist/types/src/components/GrTree/config.d.ts

@@ -0,0 +1 @@
+export declare const grTreeConfig: import("@feugene/unocss-preset-granular").GranularComponentDescriptor<"GrTree">;

package/dist/types/src/components/GrTree/grTreeDataAdapter.d.ts

@@ -0,0 +1,14 @@
+import type { GrTreeKey } from './grTreeTypes';
+import type { GrTreeDataProps } from './grTreeProps';
+export type GrTreeDataAdapterOptions<T extends object> = Pick<GrTreeDataProps<T>, 'props' | 'nodeKey'>;
+export type GrTreeDataAdapter<T extends object> = {
+    hasNodeKey: () => boolean;
+    getChildrenKey: () => string;
+    getLabelKey: () => string;
+    getLabel: (data: T) => string;
+    getChildren: (data: T) => T[];
+    ensureChildren: (data: T) => T[];
+    getNodeKey: (data: T, index: number, parentKey: GrTreeKey | undefined) => GrTreeKey;
+    getExplicitNodeKey: (data: T) => GrTreeKey | undefined;
+};
+export declare function createGrTreeDataAdapter<T extends Record<string, any> = any>(options: GrTreeDataAdapterOptions<T>): GrTreeDataAdapter<T>;

package/dist/types/src/components/GrTree/grTreeInteractionContext.d.ts

@@ -0,0 +1,31 @@
+import type { Ref, ShallowRef } from 'vue';
+import type { GrTreeAllowDropType, GrTreeKey, GrTreeNode, GrTreeNodeDropType } from './grTreeTypes';
+export type GrTreeDropTarget = {
+    key: GrTreeKey;
+    type: GrTreeNodeDropType;
+    allowed: boolean;
+};
+export type GrTreeInteractionOptions<T> = {
+    draggable?: boolean;
+    allowDrop?: (draggingNode: GrTreeNode<T>, dropNode: GrTreeNode<T>, type: GrTreeAllowDropType) => boolean;
+    allowDrag?: (draggingNode: GrTreeNode<T>) => boolean;
+};
+export type GrTreeInteractionEmitters<T> = {
+    emitNodeClick: (data: T, node: GrTreeNode<T>) => void;
+    emitNodeExpand: (data: T, node: GrTreeNode<T>) => void;
+    emitNodeCollapse: (data: T, node: GrTreeNode<T>) => void;
+    emitNodeDrop: (draggingNode: GrTreeNode<T>, dropNode: GrTreeNode<T>, dropType: GrTreeNodeDropType) => void;
+};
+export type GrTreeInteractionContext<T> = {
+    hoveredKey: Ref<GrTreeKey | undefined>;
+    draggingNode: ShallowRef<GrTreeNode<T> | null>;
+    dropTarget: ShallowRef<GrTreeDropTarget | null>;
+    canDrag: (node: GrTreeNode<T>) => boolean;
+    canDrop: (drag: GrTreeNode<T>, target: GrTreeNode<T>, type: GrTreeAllowDropType) => boolean;
+    resetDragState: () => void;
+    emitNodeClick: (data: T, node: GrTreeNode<T>) => void;
+    emitNodeExpand: (data: T, node: GrTreeNode<T>) => void;
+    emitNodeCollapse: (data: T, node: GrTreeNode<T>) => void;
+    emitNodeDrop: (draggingNode: GrTreeNode<T>, dropNode: GrTreeNode<T>, dropType: GrTreeNodeDropType) => void;
+};
+export declare function createGrTreeInteractionContext<T>(options: GrTreeInteractionOptions<T>, emitters: GrTreeInteractionEmitters<T>): GrTreeInteractionContext<T>;

package/dist/types/src/components/GrTree/grTreeProps.d.ts

@@ -0,0 +1,63 @@
+import type { HTMLAttributes } from 'vue';
+import type { GrTreeInteractionContext } from './grTreeInteractionContext';
+import type { GrTreeStore } from './grTreeStore';
+import type { GrTreeAllowDropType, GrTreeKey, GrTreeNode } from './grTreeTypes';
+export type NodeKeyProp<T extends object> = Extract<keyof T, string>;
+export type GrTreePropsMap = {
+    children?: string;
+    label?: string;
+};
+export type GrTreeFilterNodeMethod<T extends object = any> = (value: string, data: T, node?: GrTreeNode<T>) => boolean;
+export type GrTreeBranchLineColor<T extends object = any> = string | ((node: GrTreeNode<T>) => string | undefined | null);
+export type GrTreeVisibleRow<T extends object> = {
+    node: GrTreeNode<T>;
+    isExpanded: boolean;
+    isLeaf: boolean;
+    isMatched: boolean;
+};
+export type GrTreeVisibleTreeRow<T extends object> = GrTreeVisibleRow<T> & {
+    children: GrTreeVisibleTreeRow<T>[];
+};
+export type GrTreeClassValue = HTMLAttributes['class'];
+export type GrTreeNodeClass<T extends object> = GrTreeClassValue | ((row: GrTreeVisibleRow<T>) => GrTreeClassValue);
+export type GrTreeDataProps<T extends object> = {
+    data: T[];
+    props?: GrTreePropsMap;
+    nodeKey?: NodeKeyProp<T> | 'id';
+    defaultExpandedKeys?: GrTreeKey[];
+    filterNodeMethod?: GrTreeFilterNodeMethod<T>;
+};
+export type GrTreeViewProps<T extends object> = {
+    highlightCurrent?: boolean;
+    expandIcon?: string;
+    collapseIcon?: string;
+    toggleIconRotate?: boolean;
+    branchLine?: boolean;
+    branchLineColor?: GrTreeBranchLineColor<T>;
+    branchLineActiveColor?: GrTreeBranchLineColor<T>;
+    rowClass?: GrTreeNodeClass<T>;
+    dragHandleClass?: GrTreeNodeClass<T>;
+    toggleClass?: GrTreeNodeClass<T>;
+    toggleIconClass?: GrTreeNodeClass<T>;
+    toggleSpacerClass?: GrTreeNodeClass<T>;
+    contentClass?: GrTreeNodeClass<T>;
+    /** i18n-метка кнопки "Перетащить" (default: 'Drag'). */
+    dragLabel?: string;
+    /** i18n-метка кнопки "Развернуть" (default: 'Expand'). */
+    expandLabel?: string;
+    /** i18n-метка кнопки "Свернуть" (default: 'Collapse'). */
+    collapseLabel?: string;
+};
+export type GrTreeInteractionProps<T extends object> = {
+    draggable?: boolean;
+    dragHandleIcon?: string;
+    allowDrop?: (draggingNode: GrTreeNode<T>, dropNode: GrTreeNode<T>, type: GrTreeAllowDropType) => boolean;
+    allowDrag?: (draggingNode: GrTreeNode<T>) => boolean;
+};
+export type GrTreeInternalProps<T extends object> = {
+    internalRows?: GrTreeVisibleTreeRow<T>[];
+    internalNested?: boolean;
+    internalStore?: GrTreeStore<T>;
+    internalInteractionContext?: GrTreeInteractionContext<T>;
+};
+export type GrTreeProps<T extends object> = GrTreeDataProps<T> & GrTreeViewProps<T> & GrTreeInteractionProps<T> & GrTreeInternalProps<T>;

package/dist/types/src/components/GrTree/grTreeStore.d.ts

@@ -0,0 +1,45 @@
+import type { ComputedRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
+import type { GrTreeKey, GrTreeNode, GrTreeNodeDropType, GrTreeNodeTarget } from './grTreeTypes';
+import type { GrTreeDataAdapter } from './grTreeDataAdapter';
+import type { GrTreeDataProps, GrTreeFilterNodeMethod } from './grTreeProps';
+type TreeModel<T extends object> = {
+    roots: GrTreeNode<T>[];
+    byKey: Map<GrTreeKey, GrTreeNode<T>>;
+    byData: WeakMap<T, GrTreeNode<T>>;
+};
+type FilterInfo = {
+    isActive: boolean;
+    subtreeHasMatch: Map<GrTreeKey, boolean>;
+    matchedKeys: Set<GrTreeKey>;
+    autoExpandKeys: Set<GrTreeKey>;
+};
+export type GrTreeStoreOptions<T extends object> = {
+    data: MaybeRefOrGetter<GrTreeDataProps<T>['data']>;
+    defaultExpandedKeys?: MaybeRefOrGetter<GrTreeDataProps<T>['defaultExpandedKeys']>;
+    filterNodeMethod?: MaybeRefOrGetter<GrTreeFilterNodeMethod<T> | undefined>;
+    adapter: GrTreeDataAdapter<T>;
+};
+export type GrTreeStore<T extends object> = {
+    filterValue: Ref<string>;
+    expandedKeys: ShallowRef<Set<GrTreeKey>>;
+    currentKey: Ref<GrTreeKey | undefined>;
+    treeModel: ComputedRef<TreeModel<T>>;
+    filterInfo: ComputedRef<FilterInfo>;
+    filter: (value: string) => void;
+    isExpandedKey: (key: GrTreeKey) => boolean;
+    setExpandedKey: (key: GrTreeKey, expanded: boolean) => void;
+    toggleExpand: (node: GrTreeNode<T>) => void;
+    setCurrentKey: (key?: GrTreeKey) => void;
+    getCurrentKey: () => GrTreeKey | undefined;
+    getCurrentNode: () => GrTreeNode<T> | undefined;
+    setCurrentNode: (node?: GrTreeNodeTarget<T>) => boolean;
+    getNode: (key: GrTreeKey) => GrTreeNode<T> | undefined;
+    canMoveNode: (node: GrTreeNodeTarget<T>, referenceNode: GrTreeNodeTarget<T>, dropType: GrTreeNodeDropType) => boolean;
+    moveNode: (node: GrTreeNodeTarget<T>, referenceNode: GrTreeNodeTarget<T>, dropType: GrTreeNodeDropType) => GrTreeNode<T> | undefined;
+    appendNode: (data: T, parent: GrTreeNodeTarget<T>) => GrTreeNode<T> | undefined;
+    removeNode: (node: GrTreeNodeTarget<T>) => boolean;
+    insertNodeBefore: (data: T, referenceNode: GrTreeNodeTarget<T>) => GrTreeNode<T> | undefined;
+    insertNodeAfter: (data: T, referenceNode: GrTreeNodeTarget<T>) => GrTreeNode<T> | undefined;
+};
+export declare function createGrTreeStore<T extends Record<string, any> = any>(options: GrTreeStoreOptions<T>): GrTreeStore<T>;
+export {};

package/dist/types/src/components/GrTree/grTreeTypes.d.ts

@@ -0,0 +1,24 @@
+export type GrTreeKey = string | number;
+export type GrTreeNodeDropType = 'prev' | 'inner' | 'next';
+export type GrTreeAllowDropType = GrTreeNodeDropType;
+export type GrTreeNode<T = any> = {
+    key: GrTreeKey;
+    label: string;
+    data: T;
+    level: number;
+    parent?: GrTreeNode<T>;
+    childNodes: GrTreeNode<T>[];
+};
+export type GrTreeNodeTarget<T = any> = GrTreeKey | GrTreeNode<T> | T;
+export type GrTreeInstance<T = any> = {
+    filter: (value: string) => void;
+    setCurrentKey: (key?: GrTreeKey) => void;
+    getCurrentKey: () => GrTreeKey | undefined;
+    appendNode: (data: T, parent: GrTreeNodeTarget<T>) => GrTreeNode<T> | undefined;
+    removeNode: (node: GrTreeNodeTarget<T>) => boolean;
+    insertNodeBefore: (data: T, referenceNode: GrTreeNodeTarget<T>) => GrTreeNode<T> | undefined;
+    insertNodeAfter: (data: T, referenceNode: GrTreeNodeTarget<T>) => GrTreeNode<T> | undefined;
+    getCurrentNode: () => GrTreeNode<T> | undefined;
+    setCurrentNode: (node?: GrTreeNodeTarget<T>) => boolean;
+    getNode: (key: GrTreeKey) => GrTreeNode<T> | undefined;
+};

package/dist/types/src/components/GrTree/index.d.ts

@@ -0,0 +1,6 @@
+export { default } from './GrTree.vue';
+export { default as GrTree } from './GrTree.vue';
+export type { GrTreeAllowDropType, GrTreeInstance, GrTreeKey, GrTreeNode, GrTreeNodeDropType, GrTreeNodeTarget, } from './grTreeTypes';
+export type { GrTreeBranchLineColor, GrTreeFilterNodeMethod, GrTreeNodeClass, GrTreeProps, GrTreePropsMap, GrTreeVisibleRow, GrTreeVisibleTreeRow, } from './grTreeProps';
+export { grTreeConfig } from './config';
+export { grTreeSafelist } from './safelist';

package/dist/types/src/components/GrTree/safelist.d.ts

@@ -0,0 +1 @@
+export declare const grTreeSafelist: readonly ["i-lucide-chevron-right", "i-lucide-grip-vertical"];

package/dist/types/src/components/{DsTreeSelect/DsTreeSelect.vue.d.ts → GrTreeSelect/GrTreeSelect.vue.d.ts}

@@ -1,11 +1,11 @@
-import { type DsTreeNode } from '../DsTree';
-import type { DsTreeSelectModelValue, DsTreeSelectProps } from './dsTreeSelectTypes';
+import { type GrTreeNode } from '../GrTree';
+import type { GrTreeSelectModelValue, GrTreeSelectProps } from './grTreeSelectTypes';
 declare const __VLS_export: <T extends Record<string, any> = any>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & __VLS_PrettifyLocal<DsTreeSelectProps<T> & {
-        "onUpdate:modelValue"?: ((value: DsTreeSelectModelValue) => any) | undefined;
-        onChange?: ((value: DsTreeSelectModelValue) => any) | undefined;
+    props: import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & __VLS_PrettifyLocal<GrTreeSelectProps<T> & {
+        "onUpdate:modelValue"?: ((value: GrTreeSelectModelValue) => any) | undefined;
+        onChange?: ((value: GrTreeSelectModelValue) => any) | undefined;
         onClear?: (() => any) | undefined;
-        onNodeClick?: ((data: T, node: DsTreeNode<T>) => any) | undefined;
+        onNodeClick?: ((data: T, node: GrTreeNode<T>) => any) | undefined;
         onVisibleChange?: ((visible: boolean) => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
@@ -15,14 +15,14 @@ declare const __VLS_export: <T extends Record<string, any> = any>(__VLS_props: N
     slots: {
         /** Рендер значения внутри триггера (вместо дефолтного текста). */
         value?: (props: {
-            value: DsTreeSelectModelValue;
+            value: GrTreeSelectModelValue;
             labels: string[];
             displayValue: string;
             pathLabels?: string[];
         }) => any;
         /** Рендер строки дерева. */
         node?: (props: {
-            node: DsTreeNode<T>;
+            node: GrTreeNode<T>;
             data: T;
             selected: boolean;
         }) => any;
@@ -30,11 +30,11 @@ declare const __VLS_export: <T extends Record<string, any> = any>(__VLS_props: N
         empty?: () => any;
     };
     emit: {
-        (e: "update:modelValue", value: DsTreeSelectModelValue): void;
-        (e: "change", value: DsTreeSelectModelValue): void;
+        (e: "update:modelValue", value: GrTreeSelectModelValue): void;
+        (e: "change", value: GrTreeSelectModelValue): void;
         (e: "visibleChange", visible: boolean): void;
         (e: "clear"): void;
-        (e: "nodeClick", data: T, node: DsTreeNode<T>): void;
+        (e: "nodeClick", data: T, node: GrTreeNode<T>): void;
     };
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;

package/dist/types/src/components/GrTreeSelect/config.d.ts

@@ -0,0 +1 @@
+export declare const grTreeSelectConfig: import("@feugene/unocss-preset-granular").GranularComponentDescriptor<"GrTreeSelect">;

package/dist/types/src/components/GrTreeSelect/grTreeSelectStyles.d.ts

@@ -0,0 +1,10 @@
+import type { GrInputSize } from '../GrInput';
+export type GrTreeSelectState = 'default' | 'success' | 'warning' | 'danger';
+export declare const sizeClassBySize: Record<GrInputSize, string>;
+export declare const borderClassByState: Record<GrTreeSelectState, string>;
+export declare function grTreeSelectClass(options: {
+    size: GrInputSize;
+    state: GrTreeSelectState;
+    invalid: boolean;
+}): string;
+export declare const grTreeSelectPanelClass = "rounded-[var(--ds-radius-xl)] border border-[var(--brd)] bg-[var(--card)] text-[var(--card-fg)] shadow-[var(--ds-shadow-2)] overflow-hidden";

package/dist/types/src/components/GrTreeSelect/grTreeSelectTypes.d.ts

@@ -0,0 +1,33 @@
+import type { InputHTMLAttributes } from 'vue';
+import type { GrInputSize } from '../GrInput/GrInput.vue';
+import type { GrTreeFilterNodeMethod, GrTreeKey, GrTreePropsMap } from '../GrTree';
+import type { GrTreeSelectState } from './grTreeSelectStyles';
+export type GrTreeSelectModelValue = GrTreeKey | GrTreeKey[] | null;
+export type GrTreeSelectValueDisplay = 'label' | 'path';
+type NodeKeyProp<T> = keyof T & string;
+/**
+ * Пропсы публичного DS-примитива «TreeSelect».
+ */
+export interface GrTreeSelectProps<T extends object = any> {
+    modelValue: GrTreeSelectModelValue;
+    data: T[];
+    props?: GrTreePropsMap;
+    nodeKey?: NodeKeyProp<T> | 'id';
+    defaultExpandedKeys?: GrTreeKey[];
+    disabled?: boolean;
+    placeholder?: string;
+    size?: GrInputSize;
+    invalid?: boolean;
+    state?: GrTreeSelectState;
+    multiple?: boolean;
+    clearable?: boolean;
+    /** Как отображать выбранное значение в single-режиме. */
+    valueDisplay?: GrTreeSelectValueDisplay;
+    filterable?: boolean;
+    filterPlaceholder?: string;
+    filterInputmode?: InputHTMLAttributes['inputmode'];
+    filterNodeMethod?: GrTreeFilterNodeMethod<T>;
+    closeOnSelect?: boolean;
+    dropdownMaxHeight?: number;
+}
+export {};

package/dist/types/src/components/GrTreeSelect/index.d.ts

@@ -0,0 +1,5 @@
+export { default } from './GrTreeSelect.vue';
+export { default as GrTreeSelect } from './GrTreeSelect.vue';
+export type { GrTreeSelectModelValue, GrTreeSelectProps, GrTreeSelectValueDisplay } from './grTreeSelectTypes';
+export { grTreeSelectConfig } from './config';
+export { grTreeSelectSafelist } from './safelist';

package/dist/types/src/components/GrTreeSelect/safelist.d.ts

@@ -0,0 +1 @@
+export declare const grTreeSelectSafelist: string[];

package/dist/types/src/composables/useToast.d.ts

@@ -1,8 +1,8 @@
-export type ToastVariant = 'info' | 'success' | 'warning' | 'danger';
+export type GrToastTone = 'primary' | 'neutral' | 'success' | 'warning' | 'danger' | 'info' | 'slate' | 'azure';
 export type ToastInput = {
     title: string;
     message?: string;
-    variant?: ToastVariant;
+    tone?: GrToastTone;
     /**
      * Автозакрытие через N мс. `0` или отрицательное значение — «навсегда»
      * (до явного вызова `dismiss(id)` / `clear()`). По умолчанию: `3500`.
@@ -13,7 +13,7 @@ export type Toast = {
     id: string;
     title: string;
     message?: string;
-    variant: ToastVariant;
+    tone: GrToastTone;
 };
 export declare function useToast(): {
     list: import("vue").ComputedRef<import("vue").Reactive<Toast[]>>;

package/dist/types/src/granular-provider/shared.d.ts

@@ -14,7 +14,7 @@ export declare const granularityDefaultThemes: readonly GranularityThemeName[];
  * `ds<Name>Config` из `./config.ts` рядом с SFC.
  *
  * Для компонентов, у которых есть node-only вариант конфига
- * (например, `DsButton` с `tokenDefinitionsFromCssSync`), browser‑конфиг
+ * (например, `GrButton` с `tokenDefinitionsFromCssSync`), browser‑конфиг
  * остаётся здесь, а node‑вариант подставляется снаружи через
  * `createGranularityProvider(overrides)` — см. `./index.ts` (browser)
  * и `./node.ts` (node).
@@ -23,61 +23,61 @@ export declare const granularityDefaultThemes: readonly GranularityThemeName[];
  * в `apps/showcase/scripts/generate-component-api.mjs`, не ломайте его.
  */
 export declare const granularityComponentConfigs: {
-    DsAlert: GranularComponentDescriptor<"DsAlert">;
-    DsAvatar: GranularComponentDescriptor<"DsAvatar">;
-    DsBadge: GranularComponentDescriptor<"DsBadge">;
-    DsBadgeWrap: GranularComponentDescriptor<"DsBadgeWrap">;
-    DsBottomNav: GranularComponentDescriptor<"DsBottomNav">;
-    DsButton: GranularComponentDescriptor<"DsButton">;
-    DsButtonGroup: GranularComponentDescriptor<"DsButtonGroup">;
-    DsCard: GranularComponentDescriptor<"DsCard">;
-    DsCheckbox: GranularComponentDescriptor<"DsCheckbox">;
-    DsCollapse: GranularComponentDescriptor<"DsCollapse">;
-    DsConfirmDialog: GranularComponentDescriptor<"DsConfirmDialog">;
-    DsDataTable: GranularComponentDescriptor<"DsDataTable">;
-    DsDialog: GranularComponentDescriptor<"DsDialog">;
-    DsDrawer: GranularComponentDescriptor<"DsDrawer">;
-    DsDropdown: GranularComponentDescriptor<"DsDropdown">;
-    DsDropdownMenu: GranularComponentDescriptor<"DsDropdownMenu">;
-    DsEmptyState: GranularComponentDescriptor<"DsEmptyState">;
-    DsFileUpload: GranularComponentDescriptor<"DsFileUpload">;
-    DsFormField: GranularComponentDescriptor<"DsFormField">;
-    DsFormFile: GranularComponentDescriptor<"DsFormFile">;
-    DsFormSection: GranularComponentDescriptor<"DsFormSection">;
-    DsIcon: GranularComponentDescriptor<"DsIcon">;
-    DsImageViewer: GranularComponentDescriptor<"DsImageViewer">;
-    DsInput: GranularComponentDescriptor<"DsInput">;
-    DsInputTag: GranularComponentDescriptor<"DsInputTag">;
-    DsLink: GranularComponentDescriptor<"DsLink">;
-    DsList: GranularComponentDescriptor<"DsList">;
-    DsLoading: GranularComponentDescriptor<"DsLoading">;
-    DsModal: GranularComponentDescriptor<"DsModal">;
-    DsNavbar: GranularComponentDescriptor<"DsNavbar">;
-    DsNumberInput: GranularComponentDescriptor<"DsNumberInput">;
-    DsPagination: GranularComponentDescriptor<"DsPagination">;
-    DsProgressBar: GranularComponentDescriptor<"DsProgressBar">;
-    DsPromptDialog: GranularComponentDescriptor<"DsPromptDialog">;
-    DsRadio: GranularComponentDescriptor<"DsRadio">;
-    DsRadioGroup: GranularComponentDescriptor<"DsRadioGroup">;
-    DsSegmented: GranularComponentDescriptor<"DsSegmented">;
-    DsSelect: GranularComponentDescriptor<"DsSelect">;
-    DsSidebar: GranularComponentDescriptor<"DsSidebar">;
-    DsSkeleton: GranularComponentDescriptor<"DsSkeleton">;
-    DsSwitch: GranularComponentDescriptor<"DsSwitch">;
-    DsTable: GranularComponentDescriptor<"DsTable">;
-    DsTabs: GranularComponentDescriptor<"DsTabs">;
-    DsTextarea: GranularComponentDescriptor<"DsTextarea">;
-    DsToaster: GranularComponentDescriptor<"DsToaster">;
-    DsTooltip: GranularComponentDescriptor<"DsTooltip">;
-    DsTree: GranularComponentDescriptor<"DsTree">;
-    DsTreeSelect: GranularComponentDescriptor<"DsTreeSelect">;
+    GrAlert: GranularComponentDescriptor<"GrAlert">;
+    GrAvatar: GranularComponentDescriptor<"GrAvatar">;
+    GrBadge: GranularComponentDescriptor<"GrBadge">;
+    GrBadgeWrap: GranularComponentDescriptor<"GrBadgeWrap">;
+    GrBottomNav: GranularComponentDescriptor<"GrBottomNav">;
+    GrButton: GranularComponentDescriptor<"GrButton">;
+    GrButtonGroup: GranularComponentDescriptor<"GrButtonGroup">;
+    GrCard: GranularComponentDescriptor<"GrCard">;
+    GrCheckbox: GranularComponentDescriptor<"GrCheckbox">;
+    GrCollapse: GranularComponentDescriptor<"GrCollapse">;
+    GrConfirmDialog: GranularComponentDescriptor<"GrConfirmDialog">;
+    GrDataTable: GranularComponentDescriptor<"GrDataTable">;
+    GrDialog: GranularComponentDescriptor<"GrDialog">;
+    GrDrawer: GranularComponentDescriptor<"GrDrawer">;
+    GrDropdown: GranularComponentDescriptor<"GrDropdown">;
+    GrDropdownMenu: GranularComponentDescriptor<"GrDropdownMenu">;
+    GrEmptyState: GranularComponentDescriptor<"GrEmptyState">;
+    GrFileUpload: GranularComponentDescriptor<"GrFileUpload">;
+    GrFormField: GranularComponentDescriptor<"GrFormField">;
+    GrFormFile: GranularComponentDescriptor<"GrFormFile">;
+    GrFormSection: GranularComponentDescriptor<"GrFormSection">;
+    GrIcon: GranularComponentDescriptor<"GrIcon">;
+    GrImageViewer: GranularComponentDescriptor<"GrImageViewer">;
+    GrInput: GranularComponentDescriptor<"GrInput">;
+    GrInputTag: GranularComponentDescriptor<"GrInputTag">;
+    GrLink: GranularComponentDescriptor<"GrLink">;
+    GrList: GranularComponentDescriptor<"GrList">;
+    GrLoading: GranularComponentDescriptor<"GrLoading">;
+    GrModal: GranularComponentDescriptor<"GrModal">;
+    GrNavbar: GranularComponentDescriptor<"GrNavbar">;
+    GrNumberInput: GranularComponentDescriptor<"GrNumberInput">;
+    GrPagination: GranularComponentDescriptor<"GrPagination">;
+    GrProgressBar: GranularComponentDescriptor<"GrProgressBar">;
+    GrPromptDialog: GranularComponentDescriptor<"GrPromptDialog">;
+    GrRadio: GranularComponentDescriptor<"GrRadio">;
+    GrRadioGroup: GranularComponentDescriptor<"GrRadioGroup">;
+    GrSegmented: GranularComponentDescriptor<"GrSegmented">;
+    GrSelect: GranularComponentDescriptor<"GrSelect">;
+    GrSidebar: GranularComponentDescriptor<"GrSidebar">;
+    GrSkeleton: GranularComponentDescriptor<"GrSkeleton">;
+    GrSwitch: GranularComponentDescriptor<"GrSwitch">;
+    GrTable: GranularComponentDescriptor<"GrTable">;
+    GrTabs: GranularComponentDescriptor<"GrTabs">;
+    GrTextarea: GranularComponentDescriptor<"GrTextarea">;
+    GrToaster: GranularComponentDescriptor<"GrToaster">;
+    GrTooltip: GranularComponentDescriptor<"GrTooltip">;
+    GrTree: GranularComponentDescriptor<"GrTree">;
+    GrTreeSelect: GranularComponentDescriptor<"GrTreeSelect">;
 };
 export type GranularityComponentName = keyof typeof granularityComponentConfigs;
 /**
  * Собирает granular-provider пакета `@feugene/granularity`.
  *
  * Принимает массив `GranularComponentDescriptor`'ов — это компоненты,
- * у которых есть node-only вариант конфига (например, `DsButton` с
+ * у которых есть node-only вариант конфига (например, `GrButton` с
  * `tokenDefinitionsFromCssSync`). Дескрипторы с именем, которое уже
  * присутствует в базовом наборе, переопределяют его (побеждает
  * переданный снаружи), остальные — добавляются в конец списка.

package/dist/types/src/i18n/all.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Aggregated locale loaders for the Granularity package.
+ *
+ * Imported via the dedicated sub-path `@feugene/granularity/i18n/all`.
+ * Use it ONLY in environments where bundle size is not a concern
+ * (demos, Storybook, e2e, localization tooling).
+ *
+ * For production builds always prefer per-locale imports from
+ * `@feugene/granularity/i18n` so unused languages can be tree-shaken away.
+ *
+ * ```ts
+ * import all from '@feugene/granularity/i18n/all'
+ *
+ * createFintI18n({
+ *   locale: 'en',
+ *   fallbackLocale: 'en',
+ *   loaders: all, // == [en, ru, es]
+ * })
+ * ```
+ */
+import type { LocaleLoaderCollection } from '@feugene/fint-i18n/core';
+export declare const all: LocaleLoaderCollection[];
+export default all;

package/dist/types/src/i18n/messages/const.d.ts

@@ -0,0 +1 @@
+export declare const GRANULARITY_I18N_BLOCK = "gr";

package/dist/types/src/i18n/messages/en.d.ts

@@ -0,0 +1,100 @@
+/**
+ * English locale loaders for the playground app.
+ *
+ * Exported separately from other locales so that consumers (and bundlers)
+ * can import only the languages they actually need — see the
+ * "Authoring localization packages" guide in the docs.
+ */
+export declare const en: {
+    en: {
+        gr: () => Promise<{
+            default: {
+                common: {
+                    confirm: string;
+                    cancel: string;
+                    add: string;
+                    clear: string;
+                    close: string;
+                };
+                loading: {
+                    defaultText: string;
+                };
+                treeSelect: {
+                    filterPlaceholder: string;
+                    empty: string;
+                };
+                dialog: {
+                    confirm: {
+                        title: string;
+                    };
+                    prompt: {
+                        title: string;
+                        label: string;
+                        required: string;
+                    };
+                };
+                pagination: {
+                    pageSize: string;
+                    prev: string;
+                    next: string;
+                };
+                navbar: {
+                    openMenu: string;
+                };
+                colors: {
+                    neutral: string;
+                    success: string;
+                    warning: string;
+                    danger: string;
+                    info: string;
+                    primary: string;
+                    slate: string;
+                    azure: string;
+                };
+            };
+            common: {
+                confirm: string;
+                cancel: string;
+                add: string;
+                clear: string;
+                close: string;
+            };
+            loading: {
+                defaultText: string;
+            };
+            treeSelect: {
+                filterPlaceholder: string;
+                empty: string;
+            };
+            dialog: {
+                confirm: {
+                    title: string;
+                };
+                prompt: {
+                    title: string;
+                    label: string;
+                    required: string;
+                };
+            };
+            pagination: {
+                pageSize: string;
+                prev: string;
+                next: string;
+            };
+            navbar: {
+                openMenu: string;
+            };
+            colors: {
+                neutral: string;
+                success: string;
+                warning: string;
+                danger: string;
+                info: string;
+                primary: string;
+                slate: string;
+                azure: string;
+            };
+        }>;
+    };
+};
+export default en;