@headless-adminapp/app 0.0.8-0.0.9-alpha.1.0

package/src/transport/RestDataService/index.ts

@@ -0,0 +1,151 @@
+import {
+  AggregateAttribute,
+  AggregateQuery,
+  CreateRecordResult,
+  Data,
+  HttpError,
+  IDataService,
+  InferredAggregateQueryResult,
+} from '@headless-adminapp/core/transport';
+import {
+  RetriveRecordsFnOptions,
+  RetriveRecordsResult,
+} from '@headless-adminapp/core/transport/operations';
+
+interface RestDataServiceOptions {
+  endpoint: string;
+}
+
+export class RestDataService implements IDataService {
+  public constructor(protected readonly options: RestDataServiceOptions) {}
+  protected readonly headers: Record<string, string> = {};
+
+  protected async handleResponseError(response: Response) {
+    if (response.ok) {
+      return;
+    }
+
+    if (response.headers.get('content-type')?.includes('application/json')) {
+      const data = await response.json();
+
+      if (data.error) {
+        throw new HttpError(response.status, data.error);
+      }
+    }
+
+    throw new HttpError(response.status, response.statusText);
+  }
+
+  private getHeaders() {
+    return {
+      'content-type': 'application/json',
+      ...this.headers,
+    };
+  }
+
+  public setHeader(name: string, value: string) {
+    this.headers[name] = value;
+  }
+
+  public removeHeader(name: string) {
+    delete this.headers[name];
+  }
+
+  protected async execute<T = unknown, D = unknown>(data: D): Promise<T> {
+    const response: Response = await fetch(this.options.endpoint, {
+      headers: this.getHeaders(),
+      method: 'POST',
+      body: JSON.stringify(data),
+    });
+
+    await this.handleResponseError(response);
+
+    return response.json();
+  }
+
+  public async retriveRecord<T = unknown>(
+    logicalName: string,
+    id: string,
+    columns: (keyof T)[],
+    expand?: {
+      [key in keyof T]?: string[];
+    }
+  ) {
+    return this.execute<Data<T>>({
+      type: 'retriveRecord',
+      payload: {
+        logicalName,
+        id,
+        columns,
+        expand,
+      },
+    });
+  }
+
+  public async retriveRecords<T = unknown>(
+    params: RetriveRecordsFnOptions<T>
+  ): Promise<RetriveRecordsResult<T>> {
+    return this.execute<RetriveRecordsResult<T>>({
+      type: 'retriveRecords',
+      payload: params,
+    });
+  }
+
+  public async createRecord<T>(logicalName: string, data: Partial<T>) {
+    return this.execute<CreateRecordResult>({
+      type: 'createRecord',
+      payload: {
+        logicalName,
+        data,
+      },
+    });
+  }
+
+  public async updateRecord<T>(
+    logicalName: string,
+    id: string,
+    data: Partial<T>
+  ) {
+    return this.execute<CreateRecordResult>({
+      type: 'updateRecord',
+      payload: {
+        logicalName,
+        id,
+        data,
+      },
+    });
+  }
+
+  public async deleteRecord(logicalName: string, id: string) {
+    return this.execute<void>({
+      type: 'deleteRecord',
+      payload: {
+        logicalName,
+        id,
+      },
+    });
+  }
+
+  public async retriveAggregate<
+    Q extends Record<string, AggregateAttribute> = Record<
+      string,
+      AggregateAttribute
+    >
+  >(query: AggregateQuery<Q>): Promise<InferredAggregateQueryResult<Q>[]> {
+    const result = await this.execute<InferredAggregateQueryResult<Q>[]>({
+      type: 'retriveAggregate',
+      payload: query,
+    });
+
+    return result;
+  }
+
+  public async customAction<T = unknown>(
+    _actionName: string,
+    _payload: unknown
+  ): Promise<T> {
+    throw new Error(
+      'Custom action not implemented in RestDataService, to use custom actions, define a custom data service extending RestDataService'
+    );
+  }
+}

package/src/transport/context.ts

@@ -0,0 +1,6 @@
+import { IDataService } from '@headless-adminapp/core/transport';
+import { createContext } from 'react';
+
+export const DataServiceContext = createContext<IDataService | undefined>(
+  undefined
+);

package/src/transport/hooks/index.ts

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

package/src/transport/hooks/useDataService.ts

@@ -0,0 +1,13 @@
+import { useContext } from 'react';
+
+import { DataServiceContext } from '../context';
+
+export function useDataService() {
+  const context = useContext(DataServiceContext);
+  if (!context) {
+    throw new Error(
+      'DataServiceContext must be used within a DataServiceProvider'
+    );
+  }
+  return context;
+}

package/src/transport/index.ts

@@ -0,0 +1,2 @@
+export { DataServiceContext } from './context';
+export * from './hooks';

package/src/utils/calculateColumnWidths.ts

@@ -0,0 +1,72 @@
+interface ColumnWidthItem {
+  width: number; // default and minimum width
+  maxWidth: number; // maximum width
+}
+
+interface CalculateColumnWidthParams {
+  columns: ColumnWidthItem[];
+  availableWidth: number;
+  gapWidth: number;
+}
+
+interface CalculateColumnWidthResult {
+  columns: number[];
+}
+
+export function calculateColumnWidths(params: CalculateColumnWidthParams) {
+  const { columns, availableWidth, gapWidth } = params;
+
+  const totalGapWidth = gapWidth * (columns.length - 1);
+  const remainingWidth = availableWidth - totalGapWidth;
+
+  const widths = columns.map((column) => column.width);
+  const maxWidths = columns.map((column) => column.maxWidth);
+
+  extendValues(widths, maxWidths, remainingWidth);
+
+  const result: CalculateColumnWidthResult = {
+    columns: widths,
+  };
+
+  return result;
+}
+
+function extendValues(
+  values: number[],
+  maxValues: Array<number | undefined>,
+  available: number
+): number[] {
+  do {
+    const consumed = values.reduce((acc, value) => acc + value, 0);
+    const remaining = available - consumed;
+
+    if (remaining <= 0) {
+      break;
+    }
+
+    const extendableTotal = values.reduce((acc, value, index) => {
+      if (value <= 0) return acc;
+      if (maxValues[index] && value >= maxValues[index]) return acc;
+
+      return acc + value;
+    }, 0);
+
+    if (extendableTotal <= 0) {
+      break;
+    }
+
+    const ratio = remaining / extendableTotal;
+
+    for (let i = 0; i < values.length; i++) {
+      const value = values[i];
+      const maxValue = maxValues[i];
+      if (value <= 0) continue;
+      if (maxValue && value >= maxValue) continue;
+
+      const newValue = value + value * ratio;
+      values[i] = Math.min(newValue, maxValue ?? newValue);
+    }
+  } while (true);
+
+  return values;
+}

package/src/utils/index.ts

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

package/src/widget/context.ts

@@ -0,0 +1,5 @@
+import { WidgetState } from '@headless-adminapp/core/experience/insights';
+
+import { createContext } from '../mutable';
+
+export const WidgetContext = createContext<WidgetState>();

package/src/widget/hooks/index.ts

@@ -0,0 +1,11 @@
+import { WidgetState } from '@headless-adminapp/core/experience/insights';
+import { SchemaAttributes } from '@headless-adminapp/core/schema';
+
+import { useContextSelector } from '../../mutable';
+import { WidgetContext } from '../context';
+
+export function useWidgetState<
+  S extends SchemaAttributes = SchemaAttributes
+>() {
+  return useContextSelector(WidgetContext, (state) => state as WidgetState<S>);
+}

package/src/widget/index.ts

@@ -0,0 +1 @@
+export { WidgetContext } from './context';

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "references": [{ "path": "../core/tsconfig.json" }]
+}