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

package/dist/transport/InMemoryDataService/index.d.ts

@@ -0,0 +1,25 @@
+import type { Id } from '@headless-adminapp/core/attributes';
+import { Schema } from '@headless-adminapp/core/schema';
+import { AggregateAttribute, CreateRecordResult, Data, IDataService, InferredAggregateQueryResult } from '@headless-adminapp/core/transport';
+import { RetriveRecordsFnOptions, RetriveRecordsResult } from '@headless-adminapp/core/transport/operations';
+interface Options {
+    data: Record<string, unknown[]>;
+    schemas: Record<string, Schema>;
+    idGenerator: (logicalName: string, records: unknown[]) => string | number;
+}
+export declare class InMemoryDataService implements IDataService {
+    private readonly options;
+    constructor(options: Options);
+    private getSchema;
+    private getCollection;
+    retriveRecord<T = unknown>(logicalName: string, id: Id): Promise<Data<T>>;
+    retriveRecords<T = unknown>({ logicalName, }: RetriveRecordsFnOptions<T>): Promise<RetriveRecordsResult<T>>;
+    createRecord<T>(logicalName: string, data: Partial<T>): Promise<CreateRecordResult>;
+    updateRecord<T>(logicalName: string, id: string, data: Partial<T>): Promise<any>;
+    deleteRecord(logicalName: string, id: string): Promise<void>;
+    executeAction<T>(): Promise<T>;
+    getReportData<T>(): Promise<T>;
+    retriveAggregate<Q extends Record<string, AggregateAttribute> = Record<string, AggregateAttribute>>(): Promise<InferredAggregateQueryResult<Q>[]>;
+    customAction<T = unknown>(): Promise<T>;
+}
+export {};

package/dist/transport/InMemoryDataService/index.js

@@ -0,0 +1,112 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryDataService = void 0;
+class InMemoryDataService {
+    // , IActionService, IReportService
+    constructor(options) {
+        this.options = options;
+    }
+    getSchema(logicalName) {
+        const schema = this.options.schemas[logicalName];
+        if (!schema) {
+            throw new Error(`Schema for ${logicalName} not found`);
+        }
+        return schema;
+    }
+    getCollection(logicalName) {
+        if (!this.options.data[logicalName]) {
+            throw new Error(`Entity ${logicalName} not found`);
+        }
+        return this.options.data[logicalName];
+    }
+    retriveRecord(logicalName, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const schema = this.getSchema(logicalName);
+            const records = this.getCollection(logicalName);
+            const record = records.find((record) => {
+                return record[schema.idAttribute] === id;
+            });
+            if (!record) {
+                throw new Error(`Record with id ${id} not found`);
+            }
+            return record;
+        });
+    }
+    retriveRecords(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ logicalName, }) {
+            const records = this.getCollection(logicalName);
+            return {
+                logicalName,
+                records: records,
+                count: records.length,
+            };
+        });
+    }
+    createRecord(logicalName, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const schema = this.getSchema(logicalName);
+            const records = this.getCollection(logicalName);
+            const newId = this.options.idGenerator(logicalName, records);
+            const newRecord = Object.assign(Object.assign({}, data), { [schema.idAttribute]: newId });
+            records.push(newRecord);
+            return { id: newId };
+        });
+    }
+    updateRecord(logicalName, id, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const schema = this.getSchema(logicalName);
+            const records = this.getCollection(logicalName);
+            const record = records.find((record) => {
+                return record[schema.idAttribute] === id;
+            });
+            if (!record) {
+                throw new Error(`Record with id ${id} not found`);
+            }
+            Object.assign(record, data);
+            return { id };
+        });
+    }
+    deleteRecord(logicalName, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const schema = this.getSchema(logicalName);
+            const records = this.getCollection(logicalName);
+            const index = records.findIndex((record) => {
+                return record[schema.idAttribute] === id;
+            });
+            if (index === -1) {
+                throw new Error(`Record with id ${id} not found`);
+            }
+            records.splice(index, 1);
+        });
+    }
+    executeAction() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {};
+        });
+    }
+    getReportData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {};
+        });
+    }
+    retriveAggregate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+    customAction() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {};
+        });
+    }
+}
+exports.InMemoryDataService = InMemoryDataService;

package/dist/transport/RestDataService/index.d.ts

@@ -0,0 +1,25 @@
+import { AggregateAttribute, AggregateQuery, CreateRecordResult, Data, IDataService, InferredAggregateQueryResult } from '@headless-adminapp/core/transport';
+import { RetriveRecordsFnOptions, RetriveRecordsResult } from '@headless-adminapp/core/transport/operations';
+interface RestDataServiceOptions {
+    endpoint: string;
+}
+export declare class RestDataService implements IDataService {
+    protected readonly options: RestDataServiceOptions;
+    constructor(options: RestDataServiceOptions);
+    protected readonly headers: Record<string, string>;
+    protected handleResponseError(response: Response): Promise<void>;
+    private getHeaders;
+    setHeader(name: string, value: string): void;
+    removeHeader(name: string): void;
+    protected execute<T = unknown, D = unknown>(data: D): Promise<T>;
+    retriveRecord<T = unknown>(logicalName: string, id: string, columns: (keyof T)[], expand?: {
+        [key in keyof T]?: string[];
+    }): Promise<Data<T>>;
+    retriveRecords<T = unknown>(params: RetriveRecordsFnOptions<T>): Promise<RetriveRecordsResult<T>>;
+    createRecord<T>(logicalName: string, data: Partial<T>): Promise<CreateRecordResult<import("@headless-adminapp/core/attributes").Id>>;
+    updateRecord<T>(logicalName: string, id: string, data: Partial<T>): Promise<CreateRecordResult<import("@headless-adminapp/core/attributes").Id>>;
+    deleteRecord(logicalName: string, id: string): Promise<void>;
+    retriveAggregate<Q extends Record<string, AggregateAttribute> = Record<string, AggregateAttribute>>(query: AggregateQuery<Q>): Promise<InferredAggregateQueryResult<Q>[]>;
+    customAction<T = unknown>(_actionName: string, _payload: unknown): Promise<T>;
+}
+export {};

package/dist/transport/RestDataService/index.js

@@ -0,0 +1,124 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestDataService = void 0;
+const transport_1 = require("@headless-adminapp/core/transport");
+class RestDataService {
+    constructor(options) {
+        this.options = options;
+        this.headers = {};
+    }
+    handleResponseError(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (response.ok) {
+                return;
+            }
+            if ((_a = response.headers.get('content-type')) === null || _a === void 0 ? void 0 : _a.includes('application/json')) {
+                const data = yield response.json();
+                if (data.error) {
+                    throw new transport_1.HttpError(response.status, data.error);
+                }
+            }
+            throw new transport_1.HttpError(response.status, response.statusText);
+        });
+    }
+    getHeaders() {
+        return Object.assign({ 'content-type': 'application/json' }, this.headers);
+    }
+    setHeader(name, value) {
+        this.headers[name] = value;
+    }
+    removeHeader(name) {
+        delete this.headers[name];
+    }
+    execute(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(this.options.endpoint, {
+                headers: this.getHeaders(),
+                method: 'POST',
+                body: JSON.stringify(data),
+            });
+            yield this.handleResponseError(response);
+            return response.json();
+        });
+    }
+    retriveRecord(logicalName, id, columns, expand) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.execute({
+                type: 'retriveRecord',
+                payload: {
+                    logicalName,
+                    id,
+                    columns,
+                    expand,
+                },
+            });
+        });
+    }
+    retriveRecords(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.execute({
+                type: 'retriveRecords',
+                payload: params,
+            });
+        });
+    }
+    createRecord(logicalName, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.execute({
+                type: 'createRecord',
+                payload: {
+                    logicalName,
+                    data,
+                },
+            });
+        });
+    }
+    updateRecord(logicalName, id, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.execute({
+                type: 'updateRecord',
+                payload: {
+                    logicalName,
+                    id,
+                    data,
+                },
+            });
+        });
+    }
+    deleteRecord(logicalName, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.execute({
+                type: 'deleteRecord',
+                payload: {
+                    logicalName,
+                    id,
+                },
+            });
+        });
+    }
+    retriveAggregate(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.execute({
+                type: 'retriveAggregate',
+                payload: query,
+            });
+            return result;
+        });
+    }
+    customAction(_actionName, _payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Custom action not implemented in RestDataService, to use custom actions, define a custom data service extending RestDataService');
+        });
+    }
+}
+exports.RestDataService = RestDataService;

package/dist/transport/context.d.ts

@@ -0,0 +1,2 @@
+import { IDataService } from '@headless-adminapp/core/transport';
+export declare const DataServiceContext: import("react").Context<IDataService | undefined>;

package/dist/transport/context.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataServiceContext = void 0;
+const react_1 = require("react");
+exports.DataServiceContext = (0, react_1.createContext)(undefined);

package/dist/transport/hooks/index.d.ts

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

package/dist/transport/hooks/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./useDataService"), exports);

package/dist/transport/hooks/useDataService.d.ts

@@ -0,0 +1 @@
+export declare function useDataService(): import("@headless-adminapp/core/transport").IDataService;

package/dist/transport/hooks/useDataService.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataService = useDataService;
+const react_1 = require("react");
+const context_1 = require("../context");
+function useDataService() {
+    const context = (0, react_1.useContext)(context_1.DataServiceContext);
+    if (!context) {
+        throw new Error('DataServiceContext must be used within a DataServiceProvider');
+    }
+    return context;
+}

package/dist/transport/index.d.ts

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

package/dist/transport/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataServiceContext = void 0;
+var context_1 = require("./context");
+Object.defineProperty(exports, "DataServiceContext", { enumerable: true, get: function () { return context_1.DataServiceContext; } });
+__exportStar(require("./hooks"), exports);

package/dist/utils/calculateColumnWidths.d.ts

@@ -0,0 +1,14 @@
+interface ColumnWidthItem {
+    width: number;
+    maxWidth: number;
+}
+interface CalculateColumnWidthParams {
+    columns: ColumnWidthItem[];
+    availableWidth: number;
+    gapWidth: number;
+}
+interface CalculateColumnWidthResult {
+    columns: number[];
+}
+export declare function calculateColumnWidths(params: CalculateColumnWidthParams): CalculateColumnWidthResult;
+export {};

package/dist/utils/calculateColumnWidths.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateColumnWidths = calculateColumnWidths;
+function calculateColumnWidths(params) {
+    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 = {
+        columns: widths,
+    };
+    return result;
+}
+function extendValues(values, maxValues, available) {
+    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 !== null && maxValue !== void 0 ? maxValue : newValue);
+        }
+    } while (true);
+    return values;
+}

package/dist/utils/index.d.ts

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

package/dist/utils/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./calculateColumnWidths"), exports);

package/dist/widget/context.d.ts

@@ -0,0 +1,2 @@
+import { WidgetState } from '@headless-adminapp/core/experience/insights';
+export declare const WidgetContext: import("react").Context<import("../mutable").ContextValue<WidgetState<import("@headless-adminapp/core/schema").SchemaAttributes>>>;

package/dist/widget/context.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WidgetContext = void 0;
+const mutable_1 = require("../mutable");
+exports.WidgetContext = (0, mutable_1.createContext)();

package/dist/widget/hooks/index.d.ts

@@ -0,0 +1,3 @@
+import { WidgetState } from '@headless-adminapp/core/experience/insights';
+import { SchemaAttributes } from '@headless-adminapp/core/schema';
+export declare function useWidgetState<S extends SchemaAttributes = SchemaAttributes>(): WidgetState<S>;

package/dist/widget/hooks/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useWidgetState = useWidgetState;
+const mutable_1 = require("../../mutable");
+const context_1 = require("../context");
+function useWidgetState() {
+    return (0, mutable_1.useContextSelector)(context_1.WidgetContext, (state) => state);
+}

package/dist/widget/index.d.ts

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

package/dist/widget/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WidgetContext = void 0;
+var context_1 = require("./context");
+Object.defineProperty(exports, "WidgetContext", { enumerable: true, get: function () { return context_1.WidgetContext; } });

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@headless-adminapp/app",
+  "version": "0.0.8-0.0.9-alpha.1.0",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./*": {
+      "import": "./dist/*/index.js",
+      "types": "./dist/*/index.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/headless-adminapp/adminapp.git",
+    "directory": "packages/app"
+  },
+  "bugs": {
+    "url": "https://github.com/headless-adminapp/adminapp/issues"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "pnpm run build",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "peerDependencies": {
+    "@tanstack/react-query": "^5",
+    "react-hook-form": "^7"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "clsx": "2.1.1",
+    "react-custom-scrollbars-2": "^4.5.0"
+  },
+  "gitHead": "fd2c574005892ac216056df7b69837112ca35bf9"
+}

package/src/app/context.ts

@@ -0,0 +1,11 @@
+import { AppExperience } from '@headless-adminapp/core/experience/app';
+import { SchemaExperienceMetadata } from '@headless-adminapp/core/experience/schema';
+import { createContext } from 'react';
+
+export interface AppContextState {
+  app: AppExperience;
+  schemaMetadataList: SchemaExperienceMetadata[];
+  schemaMetadataDic: Record<string, SchemaExperienceMetadata>;
+}
+
+export const AppContext = createContext<AppContextState | null>(null);

package/src/app/hooks/index.ts

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

package/src/app/hooks/useAppContext.ts

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

package/src/app/index.ts

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

package/src/appearance/context.ts

@@ -0,0 +1,13 @@
+import { createContext, Dispatch, SetStateAction } from 'react';
+
+export type ColorScheme = 'system' | 'light' | 'dark';
+
+export interface AppearanceContextState {
+  colorScheme: ColorScheme;
+  brandColor: string;
+}
+
+export const AppearanceContext = createContext<
+  | [AppearanceContextState, Dispatch<SetStateAction<AppearanceContextState>>]
+  | null
+>(null);

package/src/appearance/hooks/index.ts

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

package/src/appearance/hooks/useAppearanceContext.ts

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

package/src/appearance/index.ts

@@ -0,0 +1,6 @@
+export {
+  AppearanceContext,
+  type ColorScheme,
+  type AppearanceContextState,
+} from './context';
+export * from './hooks';