@jd-data-limited/easy-fm 4.1.5 → 4.1.8

package/src/connection/database.ts

@@ -1,257 +0,0 @@
-/*
- * Copyright (c) 2023-2024. See LICENSE file for more information
- */
-
-import {EventEmitter} from 'events'
-import {generateAuthorizationHeaders} from './generateAuthorizationHeaders.js'
-import {FMError} from '../FMError.js'
-import {type LayoutInterface} from '../layouts/layoutInterface.js'
-import {Layout} from '../layouts/layout.js'
-import {type databaseOptionsBase, type databaseOptionsWithExternalSources, type Script} from '../types.js'
-import {type HostBase} from './HostBase.js'
-import {type DatabaseBase} from './databaseBase.js'
-import {type ApiLayout, type ApiResults} from '../models/apiResults.js'
-import {type DatabaseStructure} from '../databaseStructure.js'
-import fetch, {type HeadersInit, type RequestInfo, type RequestInit, type Response} from 'node-fetch'
-// @ts-expect-error - fetchWithCookies does not have available typescript types
-import fetchWithCookies, {CookieJar} from 'node-fetch-cookies'
-
-/**
- * Represents a database connection.
- * @template T - The structure of the database.
- */
-export class Database<T extends DatabaseStructure> extends EventEmitter implements DatabaseBase {
-    private _token: string = ''
-    readonly host: HostBase
-    private readonly connection_details: databaseOptionsWithExternalSources
-    private cookies = new CookieJar()
-    readonly name: string
-    readonly debug: boolean
-    readonly #layoutCache = new Map<string, Layout<any>>()
-
-    constructor (host: HostBase, conn: databaseOptionsWithExternalSources) {
-        super()
-        this.host = host
-        this.name = conn.database
-        this.connection_details = conn
-        this.debug = conn.debug ?? false
-    }
-
-    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-    private generateExternalSourceLogin (data: databaseOptionsBase) {
-        if (data.credentials.method === 'filemaker') {
-            const _data = data.credentials
-            return {
-                database: data.database,
-                username: _data.username,
-                password: _data.password
-            }
-        }
-        else {
-            throw new Error('Not yet supported login method')
-        }
-    }
-
-    /**
-     * Logs out the user by deleting the current session token.
-     * Throws an error if the user is not logged in.
-     *
-     * @returns {Promise<void>} A promise that resolves with no value once the logout is successful.
-     * @throws {Error} Throws an error if the user is not logged in.
-     */
-    async logout (): Promise<void> {
-        if (this.token === '') throw new Error('Not logged in')
-
-        const _fetch = await fetch(`${this.endpoint}/sessions/${this.token}`, {
-            method: 'DELETE',
-            headers: {
-                'content-type': 'application/json'
-            }
-        })
-        await _fetch.json()
-        this._token = ''
-    }
-
-    /**
-     * Logs in to the database. Not required, as this is often done automatically
-     *
-     * @param {boolean} [forceLogin=false] - Whether to force login even if already logged in.
-     * @throws {Error} - Throws an error if already logged in and forceLogin is false.
-     * @throws {FMError} - Throws an FMError if login fails.
-     * @return {Promise<string>} - Returns a promise that resolves to the access token upon successful login.
-     */
-    async login (forceLogin = false) {
-        if (this.token !== '' && !forceLogin) return
-
-        // Reset cookies
-        this.cookies = new CookieJar()
-
-        await this.host.getMetadata()
-
-        if (this.connection_details.credentials.method === 'token') {
-            this._token = (this.connection_details.credentials).token
-            return this.token
-        }
-        else {
-            const url = new URL(`${this.endpoint}/sessions`)
-            url.hostname = this.host.hostname
-            const res = await fetch(url, {
-                method: 'POST',
-                headers: generateAuthorizationHeaders(this.connection_details.credentials) as unknown as HeadersInit,
-                body: JSON.stringify({
-                    fmDataSource: this.connection_details.externalSources.map(i => {
-                        const _i = i
-                        return this.generateExternalSourceLogin(_i)
-                    })
-                })
-            })
-            const _res = (await res.json()) as any
-            if (res.status === 200) {
-                this._token = res.headers.get('x-fm-data-access-token') ?? ''
-                return this._token
-            }
-            else {
-                throw new FMError(
-                    _res.messages[0].code as string | number,
-                    _res.status as number,
-                    res
-                )
-            }
-        }
-    }
-
-    get token () {
-        return this._token
-    }
-
-    /**
-     * Returns the endpoint URL for the database connection.
-     *
-     * @returns {string} The endpoint URL.
-     */
-    get endpoint (): string {
-        return `${this.host.protocol}//${this.host.hostname}/fmi/data/v2/databases/${this.name}`
-    }
-
-    async _apiRequestRaw (url: URL | RequestInfo, options: RequestInit & {
-        headers?: Record<string, string>
-        useCookieJar?: boolean
-        retries?: number
-    } = {}, autoRelogin = true): Promise<Response> {
-        if (this.debug) {
-            console.log(
-                `EASYFM DEBUG: ${JSON.stringify(options)} ${
-                    url instanceof URL
-                        ? url.toString()
-                        : typeof url === 'string' ? url : url.url
-                }`
-            )
-        }
-        const reqIsToDBHost = (
-            url instanceof URL
-                ? url
-                : typeof url === 'string'
-                    ? new URL(url)
-                    : new URL(url.url)
-        ).hostname === this.host.hostname
-        if (reqIsToDBHost && this.token === '') await this.login(true)
-
-        if (!options.headers) options.headers = {}
-        if (reqIsToDBHost) options.headers.authorization = 'Bearer ' + this._token
-        // options.redirect = "manual"
-        // options.headers.cookies = this._generateCookieHeader()
-        // console.log(options.headers.cookies)
-        // options.rejectUnauthorized = this.host.verify
-
-        const _fetch: Response =
-            options.useCookieJar
-                ? await fetchWithCookies(this.cookies, url, options)
-                : await fetch(url, options)
-        // if (_fetch.headers.get('set-cookie')) {
-        //     console.log(_fetch.headers.get('set-cookie'))
-        //     for (const cookie of (_fetch.headers.get("Set-Cookie") ?? "").split("; ")) {
-        //         const cookieSplit = cookie.split('=')
-        //         console.log("COOKIE SPLIT:", cookieSplit)
-        //         if (cookieSplit[1]) this.cookies[cookieSplit[0]] = cookieSplit[1]
-        //     }
-        // }
-        // console.log(this.cookies, _fetch.status)
-        // // console.log(this, this.cookies, url)
-        // console.trace()
-        if (!_fetch.ok && (!options.retries || options.retries > 0)) {
-            if (this.debug) {
-                console.log(`EASYFM DEBUG: RE-ATTEMPTING REQUEST (${_fetch.status}) ${
-                    url instanceof URL
-                        ? url.toString()
-                        : typeof url === 'string' ? url : url.url
-                }`)
-            }
-            return await this._apiRequestRaw(url, {...options, retries: (options?.retries ?? 1) - 1})
-        }
-        else if (_fetch.status === 401 && reqIsToDBHost && autoRelogin) {
-            await this.login(true)
-            return await this._apiRequestRaw(url, options, false)
-        }
-        else return _fetch
-    }
-
-    async _apiRequestJSON<T = any>(url: URL | RequestInfo, options: RequestInit & {
-        headers?: Record<string, string>
-    } = {}): Promise<ApiResults<T>> {
-        if (!options.headers) options.headers = {}
-        options.headers['content-type'] = options.headers['content-type'] ? options.headers['content-type'] : 'application/json'
-        const _fetch = await this._apiRequestRaw(url, options)
-        const data = await _fetch.json() as ApiResults<T>
-
-        // Remove response if it is empty. This makes checking for an empty response easier
-        if (data.response && Object.keys(data.response).length === 0) delete data.response
-
-        // console.log(data.messages[0])
-        if (data.messages[0].code !== '0') {
-            throw new FMError(data.messages[0].code, _fetch.status, data)
-        }
-
-        data.httpStatus = _fetch.status
-        return data
-    }
-
-    /**
-     * Retrieves a list of layouts in the current FileMaker database.
-     *
-     * @returns {Promise<Layout[]>} A promise that resolves to an array of Layout objects.
-     * @throws {FMError} If there was an error retrieving the layouts.
-     */
-    async listLayouts (page: number = 0) {
-        const req = await this._apiRequestJSON<{ layouts: ApiLayout[] }>(`${this.endpoint}/layouts?page=${encodeURIComponent(page)}`)
-        console.log(req)
-        if (!req.response) throw new FMError(req.messages[0].code, req.httpStatus, req.messages[0].message)
-
-        const cycleLayoutNames = (layouts: ApiLayout[]) => {
-            let names: string[] = []
-            for (const layout of layouts) {
-                if (layout.folderLayoutNames) names = names.concat(cycleLayoutNames(layout.folderLayoutNames))
-                else names.push(layout.name)
-            }
-            return names
-        }
-        return cycleLayoutNames(req.response.layouts).map(layout => new Layout(this, layout))
-    }
-
-    layout<R extends keyof T['layouts']>(name: R): Layout<T['layouts'][R]>
-    layout<R extends LayoutInterface>(name: string): Layout<R>
-    layout (name: string): Layout<any> {
-        let layout = this.#layoutCache.get(name)
-        if (layout) return layout
-        layout = new Layout<LayoutInterface>(this, name)
-        this.#layoutCache.set(name, layout)
-        return layout
-    }
-
-    clearLayoutCache () {
-        this.#layoutCache.clear()
-    }
-
-    script (name: string, parameter = ''): Script {
-        return ({name, parameter} satisfies Script)
-    }
-}

package/src/connection/databaseBase.ts

@@ -1,19 +0,0 @@
-/*
- * Copyright (c) 2023-2024. See LICENSE file for more information
- */
-
-import {type HostBase} from './HostBase.js'
-import {type ApiResults} from '../models/apiResults.js'
-import {type RequestInfo, type RequestInit, type Response} from 'node-fetch'
-
-export interface DatabaseBase {
-    host: HostBase
-    readonly name: string
-    endpoint: string
-    token: string
-
-    // layouts: DatabaseStructure["layouts"]
-
-    _apiRequestJSON: <T = unknown>(url: URL | RequestInfo, options?: RequestInit & { headers?: Record<string, string> } | undefined, autoRelogin?: boolean) => Promise<ApiResults<T>>
-    _apiRequestRaw: (url: URL | RequestInfo, options?: RequestInit & { headers?: Record<string, string>, useCookieJar?: boolean } | undefined) => Promise<Response>
-}

package/src/connection/generateAuthorizationHeaders.ts

@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2023. See LICENSE file for more information
- */
-
-import {
-    type AuthorizationHeaders,
-    type AuthorizationHeadersOAuth,
-    type loginOptionsClaris,
-    type loginOptionsFileMaker,
-    type loginOptionsOAuth
-} from '../types.js'
-
-export function generateAuthorizationHeaders (credentials: loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris): AuthorizationHeaders | AuthorizationHeadersOAuth {
-    switch (credentials.method) {
-        case 'filemaker':
-            return {
-                'Content-Type': 'application/json',
-                Authorization: 'Basic ' + Buffer.from((credentials).username + ':' + (credentials).password).toString('base64')
-            } satisfies AuthorizationHeaders
-        case 'claris':
-            return {
-                'Content-Type': 'application/json',
-                Authorization: (credentials).claris.fmid
-            } satisfies AuthorizationHeaders
-        case 'oauth':
-            return {
-                'Content-Type': 'application/json',
-                'X-FM-Data-OAuth-RequestId': (credentials).oauth.requestId,
-                'X-FM-Data-OAuth-Identifier': (credentials).oauth.requestIdentifier
-            } satisfies AuthorizationHeadersOAuth
-    }
-}

package/src/connection/requestHoldable.d.ts

@@ -1,10 +0,0 @@
-import { type RequestInfo, type RequestInit, Response } from 'node-fetch';
-export declare class RequestHoldableClass {
-    #private;
-    protected cookies: any;
-    _addNewFuncToQueue(func: () => Promise<void>): void;
-    protected _holdableFetch(url: URL | RequestInfo, options: RequestInit & {
-        headers?: Record<string, string>;
-    }): Promise<Response>;
-}
-export declare function RequestHoldable<PROPS extends any[], R = any>(originalMethod: (...p: PROPS) => Promise<R>, context: ClassMethodDecoratorContext<RequestHoldableClass>): (this: RequestHoldableClass, ...args: PROPS) => Promise<R>;

package/src/connection/requestHoldable.js

@@ -1,44 +0,0 @@
-/*
- * Copyright (c) 2024. See LICENSE file for more information
- */
-// @ts-expect-error - NO types module for this
-import fetchWithCookies, { CookieJar } from 'node-fetch-cookies';
-export class RequestHoldableClass {
-    #functionQueue = [];
-    #requestsAreBeingHeld = false;
-    cookies = new CookieJar();
-    _addNewFuncToQueue(func) {
-        this.#functionQueue.push(func);
-        if (this.#functionQueue.length === 1)
-            void this.#executeQueue();
-    }
-    async _holdableFetch(url, options) {
-        url.
-            if(!this.#requestsAreBeingHeld);
-        {
-            // eslint-disable-next-line @typescript-eslint/return-await
-            return await fetchWithCookies(this.cookies, url, options);
-        }
-    }
-    async #executeQueue() {
-        while (this.#functionQueue.length !== 0) {
-            try {
-                await this.#functionQueue[0]();
-            }
-            catch (e) {
-                console.error(e);
-            }
-            this.#functionQueue.shift();
-        }
-    }
-}
-export function RequestHoldable(originalMethod, context) {
-    // eslint-disable-next-line @typescript-eslint/promise-function-async
-    function replacementMethod(...args) {
-        return new Promise((resolve, reject) => {
-            // eslint-disable-next-line @typescript-eslint/promise-function-async
-            this._addNewFuncToQueue(() => originalMethod.call(this, ...args).then(resolve).catch(reject));
-        });
-    }
-    return replacementMethod;
-}

package/src/databaseStructure.ts

@@ -1,10 +0,0 @@
-/*
- * Copyright (c) 2024. See LICENSE file for more information
- */
-
-// import * as btoa from "btoa";
-import {type LayoutInterface} from './layouts/layoutInterface.js'
-
-export interface DatabaseStructure {
-    layouts: Record<string, LayoutInterface>
-}

package/src/index.d.ts

@@ -1,18 +0,0 @@
-import FMHost from './connection/FMHost.js';
-import { FMError } from './FMError.js';
-import * as TYPES from './types.js';
-import { type PickPortals } from './types.js';
-import { Database } from './connection/database.js';
-import { Layout } from './layouts/layout.js';
-import { RecordBase } from './records/recordBase.js';
-import { LayoutRecord } from './records/layoutRecord.js';
-import { type LayoutInterface, type PortalInterface } from './layouts/layoutInterface.js';
-import { PortalRecord } from './records/portalRecord.js';
-import { Portal } from './records/portal.js';
-import { type FindRequest, type FindRequestRaw, RecordGetOperation } from './records/getOperations/recordGetOperation.js';
-import { LayoutRecordManager } from './layouts/layoutRecordManager.js';
-import { type RecordFieldsMap } from './layouts/recordFieldsMap.js';
-import { asDate, asTime, asTimestamp, query, queryEscape } from './utils/query.js';
-import { type Container, Field } from './records/field.js';
-export default FMHost;
-export { FMError, TYPES, Database, Layout, RecordBase, LayoutRecord, type LayoutInterface, type RecordFieldsMap, type PortalInterface, PortalRecord, Portal, Field, RecordGetOperation, LayoutRecordManager, type Container, type PickPortals, type FindRequestRaw, type FindRequest, query, queryEscape, asDate, asTime, asTimestamp };

package/src/index.js

@@ -1,18 +0,0 @@
-/*
- * Copyright (c) 2023-2024. See LICENSE file for more information
- */
-import FMHost from './connection/FMHost.js';
-import { FMError } from './FMError.js';
-import * as TYPES from './types.js';
-import { Database } from './connection/database.js';
-import { Layout } from './layouts/layout.js';
-import { RecordBase } from './records/recordBase.js';
-import { LayoutRecord } from './records/layoutRecord.js';
-import { PortalRecord } from './records/portalRecord.js';
-import { Portal } from './records/portal.js';
-import { RecordGetOperation } from './records/getOperations/recordGetOperation.js';
-import { LayoutRecordManager } from './layouts/layoutRecordManager.js';
-import { asDate, asTime, asTimestamp, query, queryEscape } from './utils/query.js';
-import { Field } from './records/field.js';
-export default FMHost;
-export { FMError, TYPES, Database, Layout, RecordBase, LayoutRecord, PortalRecord, Portal, Field, RecordGetOperation, LayoutRecordManager, query, queryEscape, asDate, asTime, asTimestamp };

package/src/index.ts

@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 2023-2024. See LICENSE file for more information
- */
-
-import FMHost from './connection/FMHost.js'
-import {FMError} from './FMError.js'
-import * as TYPES from './types.js'
-import {type PickPortals} from './types.js'
-import {Database} from './connection/database.js'
-import {Layout} from './layouts/layout.js'
-import {RecordBase} from './records/recordBase.js'
-import {LayoutRecord} from './records/layoutRecord.js'
-import {type LayoutInterface, type PortalInterface} from './layouts/layoutInterface.js'
-import {PortalRecord} from './records/portalRecord.js'
-import {Portal} from './records/portal.js'
-import {type FindRequest, type FindRequestRaw, RecordGetOperation} from './records/getOperations/recordGetOperation.js'
-import {LayoutRecordManager} from './layouts/layoutRecordManager.js'
-import {type RecordFieldsMap} from './layouts/recordFieldsMap.js'
-import {asDate, asTime, asTimestamp, query, queryEscape} from './utils/query.js'
-import {type Container, Field} from './records/field.js'
-
-export default FMHost
-export {
-    FMError,
-    TYPES,
-    Database,
-    Layout,
-    RecordBase,
-    LayoutRecord,
-    type LayoutInterface,
-    type RecordFieldsMap,
-    type PortalInterface,
-    PortalRecord,
-    Portal,
-    Field,
-    RecordGetOperation,
-    LayoutRecordManager,
-    type Container,
-    type PickPortals,
-    type FindRequestRaw,
-    type FindRequest,
-    query,
-    queryEscape,
-    asDate,
-    asTime,
-    asTimestamp
-}

package/src/layouts/layout.ts

@@ -1,66 +0,0 @@
-/*
- * Copyright (c) 2023-2024. See LICENSE file for more information
- */
-
-import {LayoutRecordManager} from './layoutRecordManager.js'
-import {type Script, type ScriptResult} from '../types.js'
-import {type LayoutInterface} from './layoutInterface.js'
-import {FMError} from '../FMError.js'
-import {type LayoutBase} from './layoutBase.js'
-import {type DatabaseBase} from '../connection/databaseBase.js'
-import {type ApiLayoutMetadata, type ApiScriptResult} from '../models/apiResults.js'
-
-export class Layout<T extends LayoutInterface> implements LayoutBase {
-    readonly database: DatabaseBase
-    readonly name: string
-    readonly records = new LayoutRecordManager<T>(this)
-    metadata: ApiLayoutMetadata | null = null
-
-    constructor (database: DatabaseBase, name: string) {
-        this.database = database
-        this.name = name
-    }
-
-    get endpoint () {
-        return `${this.database.endpoint}/layouts/${this.name}`
-    }
-
-    /**
-     * Executes a FileMaker script on this layout asynchronously and returns the result.
-     * @param {Script} script - The script to be executed.
-     * @returns {Promise<ScriptResult>} - A promise that resolves to the script result or rejects with an error.
-     */
-    async runScript (script: Script): Promise<ScriptResult> {
-        let url = `${this.endpoint}/script/${encodeURIComponent(script.name)}`
-        if (script.parameter) url += '?script.param=' + encodeURIComponent(script.parameter)
-        const res = await this.database._apiRequestJSON<ApiScriptResult>(url, {
-            method: 'GET'
-        })
-        if (res.response && res.messages[0].code === '0') {
-            const error = parseInt(res.response.scriptError)
-            return {
-                scriptError: error ? new FMError(error, 200, res) : undefined,
-                scriptResult: res.response.scriptResult
-            }
-        } else {
-            throw new FMError(res.messages[0].code, res.httpStatus, res)
-        }
-    }
-
-    /**
-     * Retrieves the layout metadata
-     *
-     * @returns {Promise<ApiLayoutMetadata>} The layout metadata.
-     * @throws {FMError} If an error occurs during the API request.
-     */
-    public async getLayoutMeta (): Promise<ApiLayoutMetadata> {
-        if (this.metadata) {
-            return this.metadata
-        }
-
-        const res = await this.database._apiRequestJSON<ApiLayoutMetadata>(this.endpoint)
-        if (!res.response) throw new FMError(res.messages[0].code, res.httpStatus, res)
-        this.metadata = res.response
-        return this.metadata
-    }
-}

package/src/layouts/layoutBase.ts

@@ -1,16 +0,0 @@
-/*
- * Copyright (c) 2023-2024. See LICENSE file for more information
- */
-
-import {type Script, type ScriptResult} from '../types.js'
-import {type DatabaseBase} from '../connection/databaseBase.js'
-import {type ApiLayoutMetadata} from '../models/apiResults.js'
-
-export interface LayoutBase {
-    readonly name: string
-    metadata: ApiLayoutMetadata | null
-    endpoint: string
-    runScript: (script: Script) => Promise<ScriptResult>
-    getLayoutMeta: () => Promise<ApiLayoutMetadata>
-    database: DatabaseBase
-}

package/src/layouts/layoutInterface.ts

@@ -1,13 +0,0 @@
-/*
- * Copyright (c) 2023-2024. See LICENSE file for more information
- */
-
-import {type Portal} from '../records/portal.js'
-import {type RecordFieldsMap} from './recordFieldsMap.js'
-
-export interface LayoutInterface {
-    fields: RecordFieldsMap
-    portals: PortalInterface
-}
-
-export type PortalInterface = Record<string | number | symbol, Portal<RecordFieldsMap>>

package/src/layouts/layoutRecordManager.ts

@@ -1,66 +0,0 @@
-/*
- * Copyright (c) 2023-2024. See LICENSE file for more information
- */
-
-import {LayoutRecord} from '../records/layoutRecord.js'
-import {type LayoutInterface} from './layoutInterface.js'
-import {type LayoutBase} from './layoutBase.js'
-import {type GetOperationOptions, RecordGetOperation} from '../records/getOperations/recordGetOperation.js'
-import {type PickPortals, type RecordFetchOptions} from '../types.js'
-import {type ApiFieldData} from '../models/apiResults.js'
-
-/**
- * Manager class for handling layout records.
- */
-export class LayoutRecordManager<T extends LayoutInterface> {
-    readonly layout: LayoutBase
-    constructor (layout: LayoutBase) {
-        this.layout = layout
-    }
-
-    /**
-     * Creates a new layout record with the provided options.
-     *
-     * @param {OPTIONS} options - The options for creating the layout record.
-     * @return {Promise<LayoutRecord<PickPortals<T, OPTIONS['portals'][number]>>>}
-     * The newly created layout record.
-     */
-    async create<OPTIONS extends RecordFetchOptions>(options: OPTIONS): Promise<LayoutRecord<
-    PickPortals<T, OPTIONS['portals'][number]>
-    >> {
-        const metadata = await this.layout.getLayoutMeta()
-        const fields: ApiFieldData = {}
-        for (const _field of metadata.fieldMetaData) {
-            fields[_field.name] = ''
-        }
-        const portals: Record<string, []> = {}
-        for (const _portal of Object.keys(metadata.portalMetaData)) portals[_portal] = []
-        return new LayoutRecord(this.layout, -1, 0, fields, portals)
-    }
-
-    /**
-     * Retrieves a layout record based on the given recordId.
-     *
-     * @param {number} recordId - The identifier of the record to retrieve.
-     *
-     * @returns {Promise<LayoutRecord<PickPortals<T, never>>>} - A Promise that resolves with the retrieved layout record.
-     */
-    async get (recordId: number): Promise<LayoutRecord<
-    PickPortals<T, never>
-    >> {
-        await this.layout.getLayoutMeta()
-        const record = new LayoutRecord<PickPortals<T, never>>(this.layout, recordId)
-        await record.get()
-        return record
-    }
-
-    /**
-     * Creates a new instance of RecordGetOperation with the given options.
-     *
-     * @param {Array} options - An array of options for the operation.
-     * @return {RecordGetOperation} - A new instance of RecordGetOperation.
-     */
-    list<OPTIONS extends GetOperationOptions<T>>(options: OPTIONS) {
-        return new RecordGetOperation<T, OPTIONS>(this.layout, options)
-    }
-}

package/src/layouts/recordFieldsMap.ts

@@ -1,7 +0,0 @@
-/*
- * Copyright (c) 2023-2024. See LICENSE file for more information
- */
-
-import {type Field, type FieldValue} from '../records/field.js'
-
-export type RecordFieldsMap = Record<string, Field<FieldValue>>