@astryx-vue/core 0.2.1 → 0.2.2

package/dist/index-Cs5pcwY3.d.ts

@@ -0,0 +1,416 @@
+import { a as SearchableItem, i as SearchSource } from "./useAsyncSource-xpQovjV_.js";
+import { t as PowerSearchMessages } from "./power-search-DrDfcoL1.js";
+import { Component, VNodeChild } from "vue";
+//#region src/PowerSearch/types.d.ts
+interface EmptyOperatorValue {
+  readonly type: 'empty';
+}
+interface StringOperatorValue {
+  readonly type: 'string';
+  readonly searchSource?: SearchSource;
+  readonly isArbitraryStringAllowed?: boolean;
+}
+interface OperatorTokenizationConfig {
+  readonly regex?: string;
+  readonly sort?: boolean;
+}
+interface StringListOperatorValue {
+  readonly type: 'string_list';
+  readonly searchSource?: SearchSource;
+  readonly isArbitraryStringAllowed?: boolean;
+  readonly tokenization?: OperatorTokenizationConfig;
+}
+interface IntegerOperatorValue {
+  readonly type: 'integer';
+  readonly minValue?: number;
+  readonly maxValue?: number;
+  readonly units?: string;
+}
+interface FloatOperatorValue {
+  readonly type: 'float';
+  readonly minValue?: number;
+  readonly maxValue?: number;
+  readonly units?: string;
+}
+interface TimeOperatorValue {
+  readonly type: 'time';
+  readonly minValue?: string;
+  readonly maxValue?: string;
+}
+interface DateAbsoluteOperatorValue {
+  readonly type: 'date_absolute';
+  readonly isDateOnly?: boolean;
+}
+interface DateRelativeOperatorValue {
+  readonly type: 'date_relative';
+  readonly isPastAllowed?: boolean;
+  readonly isFutureAllowed?: boolean;
+}
+type DateTimeRangePart = {
+  readonly type: 'NOW';
+} | {
+  readonly type: 'ABSOLUTE';
+  readonly unixSeconds: number;
+} | {
+  readonly type: 'RELATIVE';
+  readonly backValue: number;
+  readonly unit: 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year';
+  readonly anchorKey?: string;
+};
+interface DateTimeRange {
+  readonly start: DateTimeRangePart;
+  readonly end: DateTimeRangePart;
+}
+interface DateRangeFilterPreset {
+  readonly label: string;
+  readonly value: DateTimeRange;
+}
+interface RelativeDateFilterPreset {
+  readonly label: string;
+  readonly value: string;
+}
+interface DateRangeOperatorValue {
+  readonly type: 'date_range';
+  readonly intervalDatePresets?: readonly DateRangeFilterPreset[];
+  readonly relativeDatePresets?: readonly RelativeDateFilterPreset[];
+}
+interface EnumItem {
+  readonly value: string;
+  readonly label: string;
+  /** 内置图形名，或 `collection:icon`。 */
+  readonly icon?: string;
+}
+interface EnumOperatorValue {
+  readonly type: 'enum';
+  readonly values: readonly EnumItem[];
+}
+interface EnumListOperatorValue {
+  readonly type: 'enum_list';
+  readonly values: readonly EnumItem[];
+}
+interface EntityListOperatorValue {
+  readonly type: 'entity_list';
+  readonly searchSource?: SearchSource;
+  readonly isArbitraryStringAllowed?: boolean;
+  readonly tokenization?: OperatorTokenizationConfig;
+}
+interface CustomOperatorValue {
+  readonly type: 'custom';
+  readonly Editor: Component;
+  readonly getString: (value: string) => string;
+}
+interface NestedOperatorValue {
+  readonly type: 'nested';
+}
+type OperatorValue = EmptyOperatorValue | StringOperatorValue | StringListOperatorValue | IntegerOperatorValue | FloatOperatorValue | TimeOperatorValue | DateAbsoluteOperatorValue | DateRelativeOperatorValue | DateRangeOperatorValue | EnumOperatorValue | EnumListOperatorValue | EntityListOperatorValue | CustomOperatorValue | NestedOperatorValue;
+interface FilterValueEmpty {
+  readonly type: 'empty';
+}
+interface FilterValueString {
+  readonly type: 'string';
+  readonly value: string;
+}
+interface FilterValueStringList {
+  readonly type: 'string_list';
+  readonly value: readonly string[];
+}
+interface FilterValueInteger {
+  readonly type: 'integer';
+  readonly value: number;
+}
+interface FilterValueFloat {
+  readonly type: 'float';
+  readonly value: number;
+}
+interface FilterValueTime {
+  readonly type: 'time';
+  readonly value: string;
+}
+interface FilterValueDateAbsolute {
+  readonly type: 'date_absolute';
+  readonly unixSeconds: number;
+}
+interface FilterValueDateRelative {
+  readonly type: 'date_relative';
+  readonly value: string;
+}
+interface FilterValueDateRange {
+  readonly type: 'date_range';
+  readonly value: DateTimeRange;
+}
+interface FilterValueEnum {
+  readonly type: 'enum';
+  readonly value: string;
+}
+interface FilterValueEnumList {
+  readonly type: 'enum_list';
+  readonly value: readonly string[];
+}
+interface PowerSearchEntity {
+  readonly id: string;
+  readonly label: string;
+  readonly photo?: string;
+}
+interface FilterValueEntityList {
+  readonly type: 'entity_list';
+  readonly value: readonly PowerSearchEntity[];
+}
+interface FilterValueCustom {
+  readonly type: 'custom';
+  readonly value: string;
+}
+interface FilterValueNested {
+  readonly type: 'nested';
+  readonly value: readonly PowerSearchFilter[];
+}
+type FilterValue = FilterValueEmpty | FilterValueString | FilterValueStringList | FilterValueInteger | FilterValueFloat | FilterValueTime | FilterValueDateAbsolute | FilterValueDateRelative | FilterValueDateRange | FilterValueEnum | FilterValueEnumList | FilterValueEntityList | FilterValueCustom | FilterValueNested;
+interface PowerSearchOperatorBase {
+  readonly key: string;
+  readonly value: OperatorValue;
+}
+interface PowerSearchOperatorWithLabel extends PowerSearchOperatorBase {
+  readonly label: string;
+  readonly i18nKey?: never;
+}
+interface PowerSearchOperatorWithI18nKey extends PowerSearchOperatorBase {
+  readonly i18nKey: string;
+  readonly label?: never;
+}
+type PowerSearchOperator = PowerSearchOperatorWithLabel | PowerSearchOperatorWithI18nKey;
+interface PowerSearchField {
+  readonly key: string;
+  readonly label: string;
+  readonly operators: readonly PowerSearchOperator[];
+  readonly icon?: string;
+  readonly defaultOperator?: string;
+  readonly group?: string;
+  readonly description?: string;
+  readonly typeaheadAliases?: readonly string[];
+  readonly typeaheadMinQueryLength?: number;
+  readonly isValueMatchAllowed?: boolean;
+}
+interface PowerSearchConfig {
+  readonly name: string;
+  readonly fields: readonly PowerSearchField[];
+  readonly contentSearchFieldKey?: string;
+}
+interface PowerSearchFilter {
+  readonly field: string;
+  readonly operator: string;
+  readonly value: FilterValue;
+  readonly isReadOnly?: boolean;
+}
+interface PartialFilter {
+  readonly field: string;
+  readonly operator?: string;
+  readonly value?: FilterValue;
+  readonly isReadOnly?: boolean;
+}
+type PowerSearchChangeType = 'add' | 'edit' | 'remove';
+interface PowerSearchHandle {
+  focusTypeahead: () => void;
+  blurTypeahead: () => void;
+}
+interface PowerSearchAuxData {
+  readonly fieldKey: string;
+  readonly operatorKey?: string;
+  readonly filterValue?: FilterValue;
+  readonly filterIndex?: number;
+  readonly group?: string;
+}
+type PowerSearchItem = SearchableItem<PowerSearchAuxData>;
+type PowerSearchSize = 'sm' | 'md' | 'lg';
+type PowerSearchStatus = 'default' | 'success' | 'warning' | 'error';
+type PowerSearchStatusVariant = 'attached' | 'detached';
+type PowerSearchOverflow = 'none' | 'unfocused-inline' | 'unfocused-layer';
+interface PowerSearchTokenProps {
+  config: PowerSearchConfig;
+  filter: PowerSearchFilter;
+  field: PowerSearchField;
+  operator: PowerSearchOperator;
+  maxLength: number;
+  disabled?: boolean;
+  onClick?: () => void;
+  onRemove?: () => void;
+}
+interface PowerSearchEditorProps {
+  config: PowerSearchConfig;
+  filter: PartialFilter;
+  mode: 'create' | 'edit';
+  saveLabel?: string;
+  readOnly?: boolean;
+  timeZone?: string;
+  maxMenuItems?: number;
+  onSave: (filter: PowerSearchFilter | null) => void;
+  onCancel: () => void;
+}
+interface PowerSearchComponentOverride {
+  token?: Component;
+  editor?: Component;
+}
+type PowerSearchComponents = Partial<Record<OperatorValue['type'], PowerSearchComponentOverride>>;
+interface PowerSearchProps {
+  config: PowerSearchConfig;
+  filters?: readonly PowerSearchFilter[];
+  label?: string;
+  labelHidden?: boolean;
+  placeholder?: string;
+  autofocus?: boolean;
+  clearable?: boolean;
+  readOnly?: boolean;
+  disabled?: boolean;
+  disabledReason?: string;
+  status?: PowerSearchStatus;
+  statusMessage?: string;
+  statusVariant?: PowerSearchStatusVariant;
+  maxTokenLength?: number;
+  maxOperatorMenuItems?: number;
+  maxSearchResults?: number;
+  menuWidth?: number;
+  saveLabel?: string;
+  timeZone?: string;
+  overflow?: PowerSearchOverflow;
+  resultCount?: number | string;
+  size?: PowerSearchSize;
+  components?: PowerSearchComponents;
+}
+interface PowerSearchEmits {
+  'update:filters': [filters: PowerSearchFilter[]];
+  'change': [filters: PowerSearchFilter[], changeType: PowerSearchChangeType, index: number];
+  'focus': [event: FocusEvent];
+  'blur': [event: FocusEvent];
+}
+interface PowerSearchSlots {
+  icon?: () => VNodeChild;
+  end?: () => VNodeChild;
+  token?: (props: PowerSearchTokenProps) => VNodeChild;
+  editor?: (props: PowerSearchEditorProps) => VNodeChild;
+}
+type PowerSearchFieldType = 'string' | 'number' | 'boolean' | 'date' | 'enum' | 'enum_list' | 'string_list';
+interface PowerSearchFieldDefinition<K extends string = string, T extends PowerSearchFieldType = PowerSearchFieldType> {
+  readonly key: K;
+  readonly type: T;
+  readonly label?: string;
+  readonly enumValues?: readonly EnumItem[];
+}
+//#endregion
+//#region src/PowerSearch/config.d.ts
+interface PowerSearchLookup {
+  readonly config: PowerSearchConfig;
+  getField: (key: string) => PowerSearchField | undefined;
+  getOperator: (fieldKey: string, operatorKey: string) => PowerSearchOperator | undefined;
+  getDefaultOperator: (fieldKey: string) => PowerSearchOperator | undefined;
+  getVisibleFields: () => readonly PowerSearchField[];
+  getVisibleOperators: (fieldKey: string) => readonly PowerSearchOperator[];
+}
+declare function createPowerSearchLookup(config: PowerSearchConfig): PowerSearchLookup;
+//#endregion
+//#region src/PowerSearch/complete.d.ts
+/** 编辑器里的半成品条件。嵌套子条件放在 children，填完才写进 value。 */
+interface EditableFilter {
+  readonly field: string;
+  readonly operator?: string;
+  readonly value?: FilterValue;
+  readonly children?: readonly EditableFilter[];
+  readonly isReadOnly?: boolean;
+}
+/** 条件齐全才返回可保存的筛选。嵌套里有没填完的子条件时返回空。 */
+declare function completePowerSearchFilter(partial: EditableFilter | PartialFilter, lookup: PowerSearchLookup): PowerSearchFilter | null;
+//#endregion
+//#region src/PowerSearch/format.d.ts
+declare function formatDateAbsolute(unixSeconds: number, locale: string, timeZone?: string): string;
+declare function formatDateAbsoluteCompact(unixSeconds: number, locale: string, timeZone?: string): string;
+declare function formatFilterValue(operatorValue: OperatorValue, filterValue: FilterValue, maxLength: number, messages: PowerSearchMessages, locale: string, timeZone?: string): string;
+//#endregion
+//#region src/PowerSearch/operators.d.ts
+declare function resolveOperatorLabel(operator: PowerSearchOperator, messages: PowerSearchMessages): string;
+//#endregion
+//#region src/PowerSearch/placement.d.ts
+interface EditorBox {
+  left: number;
+  right: number;
+  width: number;
+}
+interface EditorPlacementInput {
+  outer: EditorBox;
+  control: EditorBox;
+  viewportWidth: number;
+  direction: 'ltr' | 'rtl';
+  /** 视口左右各留出的安全距离。 */
+  viewportInset?: number;
+}
+interface EditorPlacement {
+  width: number;
+  /** 编辑器比外层窄，需要对齐到打开它的控件靠近的那一侧。 */
+  capped: boolean;
+  edge: 'left' | 'right';
+  top: number;
+  left: number;
+}
+/**
+ * 编辑器宽度取外层宽度，再夹在 400 到 720 之间。
+ * 视口放不下 400 时，下限让给视口。只有被 720 压窄时，才改贴打开控件更近的外缘。
+ */
+declare function resolveEditorPlacement(input: EditorPlacementInput & {
+  anchorTop: number;
+  anchorBottom: number;
+  viewportHeight: number;
+}): EditorPlacement;
+//#endregion
+//#region src/PowerSearch/PowerSearch.vue.d.ts
+type __VLS_Slots = PowerSearchSlots;
+declare const __VLS_base: import("vue").DefineComponent<PowerSearchProps, {
+  focusTypeahead: () => void | undefined;
+  blurTypeahead: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  blur: (event: FocusEvent) => any;
+  focus: (event: FocusEvent) => any;
+  change: (filters: PowerSearchFilter[], changeType: PowerSearchChangeType, index: number) => any;
+  "update:filters": (filters: PowerSearchFilter[]) => any;
+}, string, import("vue").PublicProps, Readonly<PowerSearchProps> & Readonly<{
+  onBlur?: ((event: FocusEvent) => any) | undefined;
+  onFocus?: ((event: FocusEvent) => any) | undefined;
+  onChange?: ((filters: PowerSearchFilter[], changeType: PowerSearchChangeType, index: number) => any) | undefined;
+  "onUpdate:filters"?: ((filters: PowerSearchFilter[]) => any) | undefined;
+}>, {
+  size: PowerSearchSize;
+  status: PowerSearchStatus;
+  statusVariant: PowerSearchStatusVariant;
+  disabled: boolean;
+  labelHidden: boolean;
+  clearable: boolean;
+  overflow: PowerSearchOverflow;
+  readOnly: boolean;
+  maxTokenLength: number;
+  maxSearchResults: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/PowerSearch/query.d.ts
+interface FieldTypeToValue {
+  string: string;
+  number: number;
+  boolean: boolean;
+  date: Date | number;
+  enum: string;
+  enum_list: readonly string[];
+  string_list: readonly string[];
+}
+type InferPowerSearchData<D extends readonly PowerSearchFieldDefinition[]> = { [F in D[number] as F['key']]: FieldTypeToValue[F['type']]; };
+declare function applyPowerSearchFilters<T extends Record<string, unknown>>(filters: readonly PowerSearchFilter[], data: readonly T[]): T[];
+declare function createPowerSearchConfig<const D extends readonly PowerSearchFieldDefinition[]>(definitions: D, configName?: string): {
+  config: PowerSearchConfig;
+  applyFilters: <T extends InferPowerSearchData<D>>(filters: readonly PowerSearchFilter[], data: readonly T[]) => T[];
+};
+declare function usePowerSearchConfig<const D extends readonly PowerSearchFieldDefinition[]>(definitions: D, configName?: string): ReturnType<typeof createPowerSearchConfig<D>>;
+//#endregion
+//#region src/PowerSearch/source.d.ts
+declare function searchPowerSearchFields(lookup: PowerSearchLookup, query: string, messages: PowerSearchMessages, maxTypedResults: number): PowerSearchItem[];
+//#endregion
+export { PowerSearchItem as A, PowerSearchEmits as C, PowerSearchFieldType as D, PowerSearchFieldDefinition as E, PowerSearchSlots as F, PowerSearchStatus as I, PowerSearchOverflow as M, PowerSearchProps as N, PowerSearchFilter as O, PowerSearchSize as P, PowerSearchConfig as S, PowerSearchField as T, FilterValue as _, usePowerSearchConfig as a, PowerSearchChangeType as b, resolveOperatorLabel as c, formatFilterValue as d, completePowerSearchFilter as f, DateTimeRangePart as g, DateTimeRange as h, createPowerSearchConfig as i, PowerSearchOperator as j, PowerSearchHandle as k, formatDateAbsolute as l, createPowerSearchLookup as m, InferPowerSearchData as n, _default as o, PowerSearchLookup as p, applyPowerSearchFilters as r, resolveEditorPlacement as s, searchPowerSearchFields as t, formatDateAbsoluteCompact as u, OperatorValue as v, PowerSearchEntity as w, PowerSearchComponents as x, PartialFilter as y };

package/dist/{index-DnSrjbjP.d.ts → index-D-ZuubCK.d.ts}

@@ -32,9 +32,9 @@ declare const __VLS_base$2: import("vue").DefineComponent<ItemProps, {
   focus: typeof focus;
   blur: typeof blur;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ItemProps> & Readonly<{}>, {
-  density: ListDensity;
   isDisabled: boolean;
   as: ItemElement;
+  density: ListDensity;
   isSelected: boolean;
   align: ItemAlign;
   layout: ItemLayout;

package/dist/{index-DAiGhkNZ.d.ts → index-D4I_obqR.d.ts}

@@ -47,8 +47,8 @@ declare const __VLS_export: import("vue").DefineComponent<NumberInputProps, {},
   onChange?: ((value: number | null) => any) | undefined;
   "onUpdate:modelValue"?: ((value: number | null) => any) | undefined;
 }>, {
-  step: number;
   size: "sm" | "md" | "lg";
+  step: number;
   modelValue: number | null;
   placeholder: string;
   disabled: boolean;

package/dist/{index-I4J7gwa1.d.ts → index-DGXviOlp.d.ts}

@@ -108,9 +108,9 @@ declare const __VLS_base: import("vue").DefineComponent<SelectorProps, {}, {}, {
   onChange?: ((value: string | number | null) => any) | undefined;
   "onUpdate:modelValue"?: ((value: string | number | null) => any) | undefined;
 }>, {
-  status: SelectorStatusInput;
   size: SelectorSize;
   variant: SelectorVariant;
+  status: SelectorStatusInput;
   modelValue: string | number | null;
   isLabelHidden: boolean;
   statusVariant: SelectorStatusVariant;

package/dist/{index-BLOEjvaM.d.ts → index-DN7MXPHM.d.ts}

@@ -327,8 +327,8 @@ declare const __VLS_base$3: import("vue").DefineComponent<__VLS_PublicProps, {
   "onUpdate:isOpen"?: ((...args: unknown[]) => any) | undefined;
 }>, {
   label: string;
-  isDisabled: boolean;
   size: ContextMenuSize;
+  isDisabled: boolean;
   presentation: ContextMenuPresentation;
   triggerAs: ContextMenuTriggerElement;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;