@carlonicora/nextjs-jsonapi 1.5.0 → 1.6.0

package/dist/core/index.d.mts

@@ -1,10 +1,128 @@
-import { A as ApiData } from '../ApiData-DPKNfY-9.mjs';
-import { A as ApiDataInterface, J as JsonApiHydratedDataInterface } from '../ApiDataInterface-DPP8s46n.mjs';
-import { A as ApiRequestDataTypeInterface, M as ModuleWithPermissions, F as FieldSelector } from '../types-t2PyXhDu.mjs';
-export { G as GetterKeys, c as createJsonApiInclusion } from '../types-t2PyXhDu.mjs';
-import { A as ApiResponseInterface } from '../ApiResponseInterface-BHN5D9r5.mjs';
-export { A as AbstractApiData, a as AbstractService, H as HttpMethod, N as NextRef, P as PreviousRef, S as SelfRef, g as getGlobalErrorHandler, s as setGlobalErrorHandler } from '../AbstractService-BsY6W3Ej.mjs';
-import 'lucide-react';
+import { A as ApiData, a as ApiResponseInterface } from '../ApiResponseInterface-CfcC7pPC.mjs';
+import { A as ApiDataInterface, J as JsonApiHydratedDataInterface, a as ApiRequestDataTypeInterface, M as ModuleWithPermissions, F as FieldSelector, b as Action, p as ModuleFactory, g as ModuleInterface, f as FeatureInterface, i as RoleInterface, R as RoleInput, e as CompanyInterface, C as CompanyInput, U as UserInterface, j as UserInput, N as NotificationInterface, h as NotificationInput } from '../notification.interface-BdcwkuQE.mjs';
+export { G as GetterKeys, d as createJsonApiInclusion } from '../notification.interface-BdcwkuQE.mjs';
+import { c as AuthInterface, a as AuthInput, e as S3Interface, d as S3Input } from '../s3.interface-DlaMDRTn.mjs';
+export { A as AbstractService, b as AuthQuery, H as HttpMethod, N as NextRef, P as PreviousRef, S as SelfRef, g as getGlobalErrorHandler, s as setGlobalErrorHandler } from '../s3.interface-DlaMDRTn.mjs';
+export { B as BreadcrumbItemData } from '../breadcrumb.item.data.interface-CgB4_1EE.mjs';
+export { C as ContentFields, D as D3Link, a as D3Node, R as RoleFields, U as UserFields } from '../content.fields-Ck5lkQ5d.mjs';
+import { ClassValue } from 'clsx';
+export { ClassValue } from 'clsx';
+import * as React from 'react';
+import { ReactElement, ReactNode } from 'react';
+import { z } from 'zod';
+import { PartialBlock } from '@blocknote/core';
+import { LucideIcon } from 'lucide-react';
+export { A as AuthComponent } from '../AuthComponent-hxOPs9o8.mjs';
+import { a as ContentInterface, C as ContentInput } from '../content.interface-Bs8a7uW6.mjs';
+import 'd3';
+
+declare abstract class AbstractApiData implements ApiDataInterface {
+    protected _jsonApi?: any;
+    protected _included?: any[];
+    protected _id?: string;
+    protected _type?: string;
+    protected _createdAt?: Date;
+    protected _updatedAt?: Date;
+    protected _self?: string;
+    get type(): string;
+    get id(): string;
+    get self(): string | undefined;
+    get createdAt(): Date;
+    get updatedAt(): Date;
+    get included(): any[];
+    get jsonApi(): any;
+    ingestJsonApi(_data: JsonApiHydratedDataInterface): void;
+    generateApiUrl(_params?: any): string;
+    createJsonApi(_data?: any): any;
+    protected _readIncluded<T extends ApiDataInterface>(data: JsonApiHydratedDataInterface, type: string, dataType: ApiRequestDataTypeInterface): T | T[] | undefined;
+    dehydrate(): JsonApiHydratedDataInterface;
+    rehydrate(data: JsonApiHydratedDataInterface): this;
+}
+
+declare enum ClientHttpMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE"
+}
+interface ClientNextRef {
+    next?: string;
+}
+interface ClientPreviousRef {
+    previous?: string;
+}
+interface ClientSelfRef {
+    self?: string;
+}
+/**
+ * Set a global error handler for API errors (client-side only).
+ * This handler will be called instead of throwing errors.
+ */
+declare function setClientGlobalErrorHandler(handler: (status: number, message: string) => void): void;
+/**
+ * Get the current global error handler.
+ */
+declare function getClientGlobalErrorHandler(): ((status: number, message: string) => void) | null;
+/**
+ * Client-side abstract base class for services that interact with the JSON:API.
+ * Use this for client components.
+ */
+declare abstract class ClientAbstractService {
+    /**
+     * Extract locale from client-side URL pathname
+     * URL structure: /{locale}/route-path (e.g., /it/accounts)
+     * Fallback chain: URL locale → navigator.language → "en"
+     */
+    private static getClientLocale;
+    /**
+     * Fetch the next page of results.
+     */
+    static next<T>(params: {
+        type: ApiRequestDataTypeInterface;
+        endpoint: string;
+        next?: ClientNextRef;
+        previous?: ClientPreviousRef;
+        self?: ClientSelfRef;
+    }): Promise<T>;
+    /**
+     * Fetch the previous page of results.
+     */
+    static previous<T>(params: {
+        type: ApiRequestDataTypeInterface;
+        endpoint: string;
+        next?: ClientNextRef;
+        previous?: ClientPreviousRef;
+        self?: ClientSelfRef;
+    }): Promise<T>;
+    /**
+     * Make a client-side API call.
+     */
+    protected static callApi<T>(params: {
+        type: ApiRequestDataTypeInterface;
+        method: ClientHttpMethod;
+        endpoint: string;
+        companyId?: string;
+        input?: any;
+        overridesJsonApiCreation?: boolean;
+        next?: ClientNextRef;
+        previous?: ClientPreviousRef;
+        self?: ClientSelfRef;
+        responseType?: ApiRequestDataTypeInterface;
+        files?: {
+            [key: string]: File | Blob;
+        } | File | Blob;
+    }): Promise<T>;
+    /**
+     * Get raw JSON:API response data without deserialization.
+     */
+    protected static getRawData(params: {
+        type: ApiRequestDataTypeInterface;
+        method: ClientHttpMethod;
+        endpoint: string;
+        companyId?: string;
+    }): Promise<any>;
+}
 
 declare class JsonApiDataFactory {
     static create(classKey: ApiRequestDataTypeInterface, data: any): any;
@@ -151,4 +269,417 @@ declare function rehydrate<T extends ApiDataInterface>(classKey: ApiRequestDataT
  */
 declare function rehydrateList<T extends ApiDataInterface>(classKey: ApiRequestDataTypeInterface, data: JsonApiHydratedDataInterface[]): T[];
 
-export { ApiData, ApiDataInterface, ApiRequestDataTypeInterface, ApiResponseInterface, type AppModuleDefinitions, DataClassRegistry as DataClass, DataClassRegistry, EndpointCreator, type EndpointQuery, FieldSelector, type FoundationModuleDefinitions, JsonApiDataFactory, JsonApiHydratedDataInterface, type ModuleDefinitions, ModuleRegistrar, ModuleRegistry, Modules, RehydrationFactory, rehydrate, rehydrateList, translateData, translateResponse };
+declare function cn(...inputs: ClassValue[]): string;
+
+type PossibleRef<T> = React.Ref<T> | undefined;
+/**
+ * A utility to compose multiple refs together
+ * Accepts callback refs and RefObject(s)
+ */
+declare function composeRefs<T>(...refs: PossibleRef<T>[]): React.RefCallback<T>;
+/**
+ * A custom hook that composes multiple refs
+ * Accepts callback refs and RefObject(s)
+ */
+declare function useComposedRefs<T>(...refs: PossibleRef<T>[]): React.RefCallback<T>;
+
+declare function useIsMobile(): boolean;
+
+type FormatOption = "date" | "time" | "dateTime" | "timeSince" | "default";
+declare const formatDate: (eventDate: Date, formatOption: FormatOption) => string;
+
+declare const exists: <T>(itemOrArray: T | T[] | null | undefined) => boolean;
+
+declare class TableOptions {
+    private _components;
+    private _hasPermissionToModule;
+    constructor(hasPermissionToModule: <M extends ModuleWithPermissions>(params: {
+        module: M;
+        action: Action;
+        data?: any;
+    }) => boolean);
+    addOption<M extends ModuleWithPermissions>(component: ReactElement<any> | null, module?: M, action?: Action): void;
+    getComponents(): ReactElement<any>[];
+    getOptions(): ReactElement<any> | null;
+}
+declare function getTableOptions(params: {
+    hasPermissionToModule: <M extends ModuleWithPermissions>(params: {
+        module: M;
+        action: Action;
+        data?: any;
+    }) => boolean;
+    options: {
+        component: ReactElement<any> | null;
+        module?: ModuleWithPermissions;
+        action?: Action;
+    }[];
+}): ReactElement<any> | null;
+declare function getTableComponents(params: {
+    hasPermissionToModule: <M extends ModuleWithPermissions>(params: {
+        module: M;
+        action: Action;
+        data?: any;
+    }) => boolean;
+    options: {
+        component: ReactElement<any> | null;
+        module?: ModuleWithPermissions;
+        action?: Action;
+    }[];
+}): ReactElement<any>[];
+
+declare const userObjectSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    avatar: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type UserObject = z.infer<typeof userObjectSchema>;
+
+declare const entityObjectSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    name: z.ZodString;
+}, z.core.$strip>;
+type EntityObject = z.infer<typeof entityObjectSchema>;
+
+interface WordDiff {
+    type: "added" | "removed" | "unchanged";
+    text: string;
+    diffId: string;
+    accepted?: boolean;
+    rejected?: boolean;
+}
+interface DiffBlock {
+    id?: string;
+    type?: string;
+    props?: any;
+    content?: any;
+    children?: DiffBlock[];
+    diffType?: "added" | "removed" | "modified" | "unchanged";
+    originalContent?: any;
+    diffId?: string;
+    wordDiffs?: WordDiff[];
+    accepted?: boolean;
+    rejected?: boolean;
+}
+interface DiffResult {
+    blocks: DiffBlock[];
+    hasChanges: boolean;
+}
+interface BlockDiffOptions {
+    ignoreIds?: boolean;
+    compareContent?: boolean;
+    similarityThreshold?: number;
+}
+/**
+ * BlockNote Diff Utility
+ * Implements a sophisticated diff algorithm for BlockNote document structures
+ */
+declare class BlockNoteDiffUtil {
+    private static readonly DEFAULT_OPTIONS;
+    /**
+     * Compare two BlockNote documents and return diff result
+     */
+    static diff(originalBlocks?: PartialBlock[], newBlocks?: PartialBlock[], options?: BlockDiffOptions): DiffResult;
+    /**
+     * Compare two blocks for equality
+     */
+    private static areBlocksEqual;
+    /**
+     * Deep equality comparison for objects
+     */
+    private static deepEqual;
+    /**
+     * Sort diff blocks to maintain logical order
+     */
+    private static sortDiffBlocks;
+    /**
+     * Calculate similarity between two text contents
+     */
+    private static calculateSimilarity;
+    /**
+     * Extract plain text from BlockNote content array
+     */
+    private static extractTextFromContent;
+    /**
+     * Calculate Levenshtein distance between two strings
+     */
+    private static levenshteinDistance;
+    /**
+     * Generate word-level diffs between two content arrays
+     */
+    static generateWordDiffs(originalContent: any, newContent: any, blockId: string): WordDiff[];
+    /**
+     * Perform word-level diff using word-only approach (no space tokenization)
+     */
+    private static diffWords; /**
+     * Improved diff algorithm that better handles word insertions
+     * Uses a combination of LCS and heuristics to minimize false changes
+     */
+    private static myersDiff;
+    /**
+     * Compute edit script using dynamic programming
+     */
+    private static computeEditScript;
+    /**
+     * Reconstruct the actual diff from the DP table
+     */
+    private static reconstructDiff;
+    /**
+     * Consolidate adjacent changes to reduce fragmentation
+     * e.g., if we have: delete "Key", insert "Key!", delete "Challenges"
+     * We can consolidate this into: replace ["Key", "Challenges"] with ["Key!"]
+     */
+    private static consolidateAdjacentChanges;
+    /**
+     * Determine if a sequence of changes should be consolidated
+     */
+    private static shouldConsolidateChanges;
+    /**
+     * Check if two words are similar enough to be considered a replacement
+     */
+    private static areWordsSimilar;
+}
+
+declare class BlockNoteWordDiffRendererUtil {
+    static renderWordDiffs(diffBlocks: DiffBlock[], onAcceptChange?: (diffId: string) => void, onRejectChange?: (diffId: string) => void, acceptedChanges?: Set<string>, rejectedChanges?: Set<string>): PartialBlock[];
+    private static updateWordDiffStates;
+    private static renderDiffBlock;
+    private static renderBlockLevelDiff;
+    private static renderWordLevelDiff;
+    private static groupAndRenderWordDiffs;
+    private static cleanupSpaces;
+    private static isLastDiffInGroup;
+    private static createTextContent;
+    private static getBlockProps;
+    static generateChangeSummary(diffBlocks: DiffBlock[]): {
+        totalWords: number;
+        addedWords: number;
+        removedWords: number;
+        acceptedChanges: number;
+        rejectedChanges: number;
+        pendingChanges: number;
+    };
+}
+
+declare const getIconByModule: (params: {
+    module: ModuleWithPermissions;
+    className?: string;
+}) => ReactNode;
+declare const getIcon: (params: {
+    element: ApiDataInterface;
+    className?: string;
+}) => ReactNode;
+declare const getIconByModuleName: (params: {
+    name: string;
+    className?: string;
+}) => ReactNode;
+declare const getLucideIcon: (params: {
+    element: ApiDataInterface;
+}) => LucideIcon | null;
+declare const getLucideIconByModule: (params: {
+    module: ModuleWithPermissions;
+}) => LucideIcon | null;
+declare const getLucideIconByModuleName: (params: {
+    name: string;
+}) => LucideIcon | null;
+
+declare const ModuleModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
+declare class Module extends AbstractApiData implements ModuleInterface {
+    private _name?;
+    private _isCore?;
+    private _permissions?;
+    get name(): string;
+    get isCore(): boolean;
+    get permissions(): {
+        create: boolean | string;
+        read: boolean | string;
+        update: boolean | string;
+        delete: boolean | string;
+    };
+    rehydrate(data: JsonApiHydratedDataInterface): this;
+}
+
+declare const FeatureModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
+declare class Feature extends AbstractApiData implements FeatureInterface {
+    private _name?;
+    private _isProduction?;
+    private _modules;
+    get name(): string;
+    get isProduction(): boolean;
+    get modules(): ModuleInterface[];
+    rehydrate(data: JsonApiHydratedDataInterface): this;
+}
+
+declare const AuthorModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
+declare class Role extends AbstractApiData implements RoleInterface {
+    private _name?;
+    private _description?;
+    private _isSelectable?;
+    private _requiredFeature?;
+    get name(): string;
+    get description(): string;
+    get isSelectable(): boolean;
+    get requiredFeature(): FeatureInterface | undefined;
+    rehydrate(data: JsonApiHydratedDataInterface): this;
+    createJsonApi(data: RoleInput): any;
+}
+
+declare const RoleModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
+declare const CompanyModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
+declare class Company extends AbstractApiData implements CompanyInterface {
+    private _name?;
+    private _logo?;
+    private _logoUrl?;
+    private _configurations?;
+    private _licenseExpirationDate?;
+    private _features?;
+    private _modules?;
+    get name(): string;
+    get logo(): string | undefined;
+    get logoUrl(): string | undefined;
+    get licenseExpirationDate(): Date | undefined;
+    get features(): FeatureInterface[];
+    get modules(): ModuleInterface[];
+    get configurations(): any | undefined;
+    rehydrate(data: JsonApiHydratedDataInterface): this;
+    createJsonApi(data: CompanyInput): any;
+}
+
+declare enum CompanyFields {
+    companyId = "companyId",
+    name = "name",
+    createdAt = "createdAt",
+    updatedAt = "updatedAt"
+}
+
+interface SearchResultInterface {
+    get searchResult(): string;
+}
+
+declare class User extends AbstractApiData implements UserInterface, SearchResultInterface {
+    private _name?;
+    private _email?;
+    private _title?;
+    private _bio?;
+    private _avatar?;
+    private _avatarUrl?;
+    private _phone?;
+    private _rate?;
+    private _isActivated?;
+    private _isDeleted?;
+    private _lastLogin?;
+    private _relevance?;
+    private _roles;
+    private _company?;
+    private _modules;
+    get searchResult(): string;
+    get name(): string;
+    get email(): string;
+    get title(): string;
+    get bio(): string;
+    get avatar(): string | undefined;
+    get avatarUrl(): string | undefined;
+    get phone(): string | undefined;
+    get rate(): number | undefined;
+    get relevance(): number | undefined;
+    get isActivated(): boolean;
+    get isDeleted(): boolean;
+    get lastLogin(): Date | undefined;
+    get roles(): RoleInterface[];
+    get company(): CompanyInterface | undefined;
+    get modules(): ModuleInterface[];
+    rehydrate(data: JsonApiHydratedDataInterface): this;
+    createJsonApi(data: UserInput): any;
+}
+
+declare const UserModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
+declare class Auth extends AbstractApiData implements AuthInterface {
+    private _token?;
+    private _refreshToken?;
+    private _user?;
+    get token(): string;
+    get refreshToken(): string;
+    get user(): UserInterface;
+    rehydrate(data: JsonApiHydratedDataInterface): this;
+    createJsonApi(data: AuthInput): any;
+}
+
+declare const AuthModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
+declare class Content extends AbstractApiData implements ContentInterface, SearchResultInterface {
+    private _contentType?;
+    private _name?;
+    private _abstract?;
+    private _tldr?;
+    private _aiStatus?;
+    private _relevance?;
+    private _author?;
+    private _editors?;
+    get searchResult(): string;
+    get contentType(): string | undefined;
+    get name(): string;
+    get abstract(): string | undefined;
+    get tldr(): string | undefined;
+    get aiStatus(): string;
+    get relevance(): number | undefined;
+    get author(): UserInterface;
+    get editors(): UserInterface[];
+    rehydrate(data: JsonApiHydratedDataInterface): this;
+    protected addContentInput(response: any, data: ContentInput): void;
+}
+
+declare const ContentModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
+declare class Notification extends AbstractApiData implements NotificationInterface {
+    private _notificationType?;
+    private _isRead?;
+    private _actor?;
+    get notificationType(): string;
+    get isRead(): boolean;
+    get actor(): UserInterface | undefined;
+    rehydrate(data: JsonApiHydratedDataInterface): this;
+    createJsonApi(data: NotificationInput): any;
+}
+
+declare enum NotificationFields {
+    notificationId = "notificationId",
+    name = "name",
+    createdAt = "createdAt",
+    updatedAt = "updatedAt"
+}
+
+declare const NotificationModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
+type PushInput = {
+    key: string;
+    contentType?: string;
+};
+interface PushInterface extends ApiDataInterface {
+}
+
+declare class Push extends AbstractApiData implements PushInterface {
+    createJsonApi(data: PushInput): any;
+}
+
+declare const PushModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
+declare const S3Module: (factory: ModuleFactory) => ModuleWithPermissions;
+
+declare class S3 extends AbstractApiData implements S3Interface {
+    private _url?;
+    private _storageType?;
+    private _contentType?;
+    private _blobType?;
+    private _acl?;
+    get url(): string;
+    get headers(): Record<string, string>;
+    rehydrate(data: JsonApiHydratedDataInterface): this;
+    createJsonApi(data: S3Input): any;
+}
+
+export { AbstractApiData, ApiData, ApiDataInterface, ApiRequestDataTypeInterface, ApiResponseInterface, type AppModuleDefinitions, Auth, AuthInput, AuthInterface, AuthModule, AuthorModule, type BlockDiffOptions, BlockNoteDiffUtil, BlockNoteWordDiffRendererUtil, ClientAbstractService, ClientHttpMethod, type ClientNextRef, type ClientPreviousRef, type ClientSelfRef, Company, CompanyFields, CompanyInput, CompanyInterface, CompanyModule, Content, ContentInput, ContentInterface, ContentModule, DataClassRegistry as DataClass, DataClassRegistry, type DiffBlock, type DiffResult, EndpointCreator, type EndpointQuery, type EntityObject, Feature, FeatureInterface, FeatureModule, FieldSelector, type FormatOption, type FoundationModuleDefinitions, JsonApiDataFactory, JsonApiHydratedDataInterface, Module, type ModuleDefinitions, ModuleInterface, ModuleModule, ModuleRegistrar, ModuleRegistry, Modules, Notification, NotificationFields, NotificationInput, NotificationInterface, NotificationModule, Push, type PushInput, type PushInterface, PushModule, RehydrationFactory, Role, RoleInput, RoleInterface, RoleModule, S3, S3Input, S3Interface, S3Module, type SearchResultInterface, TableOptions, User, UserInput, UserInterface, UserModule, type UserObject, type WordDiff, cn, composeRefs, entityObjectSchema, exists, formatDate, getClientGlobalErrorHandler, getIcon, getIconByModule, getIconByModuleName, getLucideIcon, getLucideIconByModule, getLucideIconByModuleName, getTableComponents, getTableOptions, rehydrate, rehydrateList, setClientGlobalErrorHandler, translateData, translateResponse, useComposedRefs, useIsMobile, userObjectSchema };