@xen-orchestra/web-core 0.35.0 → 0.36.0

package/lib/packages/table/define-table/define-multi-source-table.ts

@@ -1,39 +0,0 @@
-import { type MaybeRefOrGetter } from 'vue'
-import { type Sources, type TransformProperty, transformSources } from '..'
-
-export function defineMultiSourceTable<
-  TSources extends Record<string, Sources>,
-  TConfig extends Record<string, unknown> = Record<string, unknown>,
->(setup: (sources: TSources, config: TConfig) => any) {
-  return function useTable<
-    TUseSources extends {
-      [K in keyof TSources]: any
-    },
-    TTransforms extends {
-      [K in keyof TSources]: TSources[K] extends Sources<infer T>
-        ? TransformProperty<T, TUseSources[K], K & string>[K & string]
-        : never
-    },
-  >(
-    sources: {
-      [K in keyof TUseSources]: MaybeRefOrGetter<TUseSources[K][]>
-    },
-    config: TConfig &
-      (Record<keyof TTransforms, undefined> extends TTransforms
-        ? { transform?: Partial<TTransforms> }
-        : {
-            transform: { [K in keyof TTransforms as undefined extends TTransforms[K] ? K : never]?: TTransforms[K] } & {
-              [K in keyof TTransforms as undefined extends TTransforms[K] ? never : K]: TTransforms[K]
-            }
-          })
-  ) {
-    const transformedSources = Object.fromEntries(
-      Object.entries(sources).map(([key, value]) => [
-        key,
-        transformSources(value, (config.transform as any)?.[key as any]),
-      ])
-    )
-
-    return setup(transformedSources as TSources, config)
-  }
-}

package/lib/packages/table/define-table/define-table.ts

@@ -1,13 +0,0 @@
-import { type MaybeRefOrGetter } from 'vue'
-import { type Sources, type TableVNode, type TransformProperty, transformSources } from '..'
-
-export function defineTable<TSource, TConfig extends Record<string, unknown> = Record<string, unknown>>(
-  setup: (sources: Sources<TSource>, config: TConfig) => () => TableVNode
-) {
-  return function useTable<TUseSource>(
-    sources: MaybeRefOrGetter<TUseSource[]>,
-    config: TConfig & TransformProperty<TSource, TUseSource>
-  ) {
-    return setup(transformSources<TSource>(sources, config?.transform), config)
-  }
-}

package/lib/packages/table/define-table/define-typed-table.ts

@@ -1,18 +0,0 @@
-import { type MaybeRefOrGetter } from 'vue'
-import { type Sources, type TransformProperty, transformSources } from '..'
-
-export function defineTypedTable<
-  TTypedSource extends { type: string; data: Sources },
-  TConfig extends Record<string, unknown> = Record<string, unknown>,
->(setup: (typedSource: TTypedSource, config: TConfig) => any) {
-  return function useTable<
-    TUseSource,
-    const TType extends TTypedSource['type'],
-    TSource extends TTypedSource extends { type: TType; data: Sources<infer TSource> } ? TSource : never,
-  >(type: TType, sources: MaybeRefOrGetter<TUseSource[]>, config: TConfig & TransformProperty<TSource, TUseSource>) {
-    return setup(
-      { type, data: transformSources<TSource>(sources, config.transform) } as unknown as TTypedSource,
-      config
-    )
-  }
-}

package/lib/packages/table/transform-sources.ts

@@ -1,13 +0,0 @@
-import { useArrayMap } from '@vueuse/shared'
-import { type MaybeRefOrGetter, type ComputedRef, computed, toValue } from 'vue'
-
-export function transformSources<TSource>(
-  sources: MaybeRefOrGetter<any[]>,
-  transformer?: (source: any, index: number) => any
-) {
-  return transformer
-    ? (useArrayMap(sources, (source, index) => ({ ...source, ...transformer!(source, index) })) as ComputedRef<
-        TSource[]
-      >)
-    : (computed(() => toValue(sources)) as unknown as ComputedRef<TSource[]>)
-}

package/lib/packages/table/types/extensions.ts

@@ -1,16 +0,0 @@
-import type { PropsOverride, Renderer } from '.'
-
-export type Extension<
-  TConfig extends Record<string, any> = Record<string, any>,
-  TComponentProps extends Record<string, any> = Record<string, any>,
-> = (config: TConfig) => { props: PropsOverride<TComponentProps> }
-
-export type Extensions<TComponentProps extends Record<string, any>> = Record<string, Extension<any, TComponentProps>>
-
-export type ExtensionConfig<
-  TRenderer extends Renderer<any, any, any>,
-  TExtensionName extends keyof $Extensions,
-  $Extensions extends Record<string, any> = TRenderer extends Renderer<any, infer TExtensions, any>
-    ? { [K in keyof TExtensions]: Parameters<TExtensions[K]>[0] }
-    : never,
-> = $Extensions[TExtensionName]

package/lib/packages/table/types/index.ts

@@ -1,47 +0,0 @@
-import type { Extensions, TableRenderer, TableCellRenderer, TableRowRenderer, TableSectionRenderer } from '.'
-import type { ComputedRef } from 'vue'
-
-export * from './table-cell'
-export * from './table-row'
-export * from './extensions'
-export * from './table'
-export * from './table-section'
-
-export type ComponentLoader<TProps> = () => Promise<{
-  default: abstract new () => {
-    $props: TProps
-  }
-}>
-
-export type PropsOverride<TComponentProps> = Partial<TComponentProps> & Record<string, any>
-
-export type Renderer<
-  TComponentProps extends Record<string, any>,
-  TExtensions extends Extensions<TComponentProps>,
-  TPropsConfig extends Record<string, any>,
-> =
-  | TableRenderer<TComponentProps, TExtensions, TPropsConfig>
-  | TableSectionRenderer<TComponentProps, TExtensions, TPropsConfig>
-  | TableRowRenderer<TComponentProps, TExtensions, TPropsConfig>
-  | TableCellRenderer<TComponentProps, TExtensions, TPropsConfig>
-
-export type Sources<T = any> = ComputedRef<T[]>
-
-export type TransformProperty<
-  TSource,
-  TUseSource,
-  TPropertyName extends string = 'transform',
-> = TUseSource extends TSource
-  ? { [K in TPropertyName]?: (source: TUseSource, index: number) => Partial<TSource> }
-  : {
-      [K in TPropertyName]: (
-        source: TUseSource,
-        index: number
-      ) => Partial<TSource> & {
-        [K in keyof TSource as K extends keyof TUseSource
-          ? TUseSource[K] extends TSource[K]
-            ? never
-            : K
-          : K]: TSource[K]
-      }
-    }

package/lib/packages/table/types/table-cell.ts

@@ -1,18 +0,0 @@
-import type { Branded } from '@core/types/utility.type'
-import type { PropsOverride, Extensions } from '.'
-import type { VNode } from 'vue'
-
-export type TableCellVNode = Branded<'CellVNode', VNode>
-
-export type TableCellVNodes = TableCellVNode | TableCellVNodes[]
-
-export type TableCellRenderer<
-  TComponentProps extends Record<string, any>,
-  TExtensions extends Extensions<TComponentProps>,
-  TPropsConfig extends Record<string, any>,
-> = (
-  renderConfig: {
-    extensions?: { [K in keyof TExtensions]?: Parameters<TExtensions[K]>[0] }
-    props?: PropsOverride<TComponentProps>
-  } & TPropsConfig
-) => TableCellVNode

package/lib/packages/table/types/table-row.ts

@@ -1,20 +0,0 @@
-import type { Branded } from '@core/types/utility.type'
-import type { PropsOverride, Extensions, TableCellVNodes } from '.'
-import type { VNode } from 'vue'
-
-export type TableRowVNode = Branded<'RowVNode', VNode>
-
-export type TableRowVNodes = TableRowVNode | TableRowVNodes[]
-
-export type TableRowRenderer<
-  TComponentProps extends Record<string, any>,
-  TExtensions extends Extensions<TComponentProps>,
-  TPropsConfig extends Record<string, any>,
-> = (
-  renderConfig: {
-    extensions?: { [K in keyof TExtensions]?: Parameters<TExtensions[K]>[0] }
-    key: string | number
-    props?: PropsOverride<TComponentProps>
-    cells: () => TableCellVNodes
-  } & TPropsConfig
-) => TableRowVNode

package/lib/packages/table/types/table-section.ts

@@ -1,19 +0,0 @@
-import type { Branded } from '@core/types/utility.type'
-import type { PropsOverride, Extensions, TableRowVNodes } from '.'
-import type { VNode } from 'vue'
-
-export type TableSectionVNode = Branded<'SectionVNode', VNode>
-
-export type TableSectionVNodes = TableSectionVNode | TableSectionVNodes[]
-
-export type TableSectionRenderer<
-  TComponentProps extends Record<string, any>,
-  TExtensions extends Extensions<TComponentProps>,
-  TPropsConfig extends Record<string, any>,
-> = (
-  renderConfig: {
-    extensions?: { [K in keyof TExtensions]?: Parameters<TExtensions[K]>[0] }
-    rows: () => TableRowVNodes
-    props?: PropsOverride<TComponentProps>
-  } & TPropsConfig
-) => TableSectionVNode

package/lib/packages/table/types/table.ts

@@ -1,28 +0,0 @@
-import type { Branded } from '@core/types/utility.type'
-import type {
-  TableCellVNodes,
-  PropsOverride,
-  TableRowVNodes,
-  TableSectionVNode,
-  TableSectionVNodes,
-  Extensions,
-} from '.'
-import type { VNode } from 'vue'
-
-export type TableVNode = Branded<'TableVNode', VNode>
-
-export type TableRenderer<
-  TComponentProps extends Record<string, any>,
-  TExtensions extends Extensions<TComponentProps>,
-  TPropsConfig extends Record<string, any>,
-> = (
-  renderConfig: {
-    extensions?: { [K in keyof TExtensions]?: Parameters<TExtensions[K]>[0] }
-    props?: PropsOverride<TComponentProps>
-    thead:
-      | (() => TableSectionVNode)
-      | { rows: () => TableRowVNodes; cells?: never }
-      | { rows?: never; cells: () => TableCellVNodes }
-    tbody: (() => TableSectionVNodes) | { rows: () => TableRowVNodes }
-  } & TPropsConfig
-) => TableVNode

package/lib/types/button.type.ts

@@ -1,3 +0,0 @@
-export type ButtonLevel = 'primary' | 'secondary' | 'tertiary'
-
-export type ButtonSize = 'small' | 'medium' | 'large'