@opra/core 0.0.12 → 0.1.0

package/esm/implementation/resource/container-resource-handler.js

@@ -1,26 +0,0 @@
-import { EntityResourceHandler } from './entity-resource-handler.js';
-import { ResourceHandler } from './resource-handler.js';
-export class ContainerResourceHandler extends ResourceHandler {
-    constructor(args) {
-        super({
-            kind: 'ContainerResource',
-            ...args
-        });
-    }
-    getResource(name) {
-        const t = this._args.resources[name];
-        if (!t)
-            throw new Error(`Resource "${name}" does not exists`);
-        return t;
-    }
-    getEntityResource(name) {
-        const t = this.getResource(name);
-        if (!(t instanceof EntityResourceHandler))
-            throw new Error(`"${name}" is not an EntityResource`);
-        return t;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    execute(ctx) {
-        return Promise.resolve(undefined);
-    }
-}

package/esm/implementation/resource/entity-resource-handler.d.ts

@@ -1,18 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { OpraSchema } from '@opra/schema';
-import { EntityType } from '../data-type/entity-type.js';
-import { OpraService } from '../opra-service.js';
-import { QueryContext } from '../query-context.js';
-import { ResourceHandler } from './resource-handler.js';
-export declare type EntityResourceControllerArgs = StrictOmit<OpraSchema.EntityResource, 'kind'> & {
-    service: OpraService;
-    dataType: EntityType;
-};
-export declare class EntityResourceHandler extends ResourceHandler {
-    protected readonly _args: OpraSchema.EntityResource;
-    readonly service: OpraService;
-    readonly dataType: EntityType;
-    constructor(args: EntityResourceControllerArgs);
-    execute(ctx: QueryContext): Promise<void>;
-    _executeFn(ctx: QueryContext, fnName: string): Promise<any>;
-}

package/esm/implementation/resource/entity-resource-handler.js

@@ -1,75 +0,0 @@
-import _ from 'lodash';
-import { OpraQuery } from '../../interfaces/query.interface.js';
-import { EntityType } from '../data-type/entity-type.js';
-import { ResourceHandler } from './resource-handler.js';
-var isSearchQuery = OpraQuery.isSearchQuery;
-import { UnprocessableEntityError } from '../../exception/index.js';
-export class EntityResourceHandler extends ResourceHandler {
-    service;
-    dataType;
-    constructor(args) {
-        super({
-            kind: 'EntityResource',
-            ..._.omit(args, ['dataType', 'service'])
-        });
-        this.dataType = args.dataType;
-        this.service = args.service;
-        // noinspection SuspiciousTypeOfGuard
-        if (!(args.dataType instanceof EntityType))
-            throw new TypeError(`You should provide an EntityType for EntityResourceController`);
-    }
-    async execute(ctx) {
-        const { query } = ctx;
-        if (isSearchQuery(query)) {
-            const promises = [];
-            let search;
-            let count;
-            promises.push(this._executeFn(ctx, query.queryType)
-                .then(v => search = v));
-            if (query.count) {
-                promises.push(this._executeFn(ctx, 'count')
-                    .then(v => count = v));
-            }
-            await Promise.all(promises);
-            ctx.response.value = {
-                ...search,
-                ...count
-            };
-            return;
-        }
-        ctx.response.value = await this._executeFn(ctx, query.queryType);
-    }
-    async _executeFn(ctx, fnName) {
-        const fn = this._args[fnName];
-        let result = typeof fn === 'function' ? (await fn(ctx)) : undefined;
-        switch (fnName) {
-            case 'search':
-                return { items: Array.isArray(result) ? result : (ctx.response.value ? [result] : []) };
-            case 'count':
-                return { count: result || 0 };
-            case 'delete':
-            case 'deleteMany':
-            case 'updateMany':
-                let affectedRecords;
-                if (typeof result === 'number')
-                    affectedRecords = result;
-                if (typeof result === 'boolean')
-                    affectedRecords = result ? 1 : 0;
-                if (typeof result === 'object')
-                    affectedRecords = result.affectedRows || result.affectedRecords;
-                return { affectedRecords };
-        }
-        result = Array.isArray(result) ? result[0] : result;
-        if (!result)
-            throw new UnprocessableEntityError();
-        if (ctx.resultPath) {
-            const pathArray = ctx.resultPath.split('.');
-            for (const property of pathArray) {
-                result = result && typeof result === 'object' && result[property];
-            }
-        }
-        if (fnName === 'create')
-            ctx.response.status = 201;
-        return result;
-    }
-}

package/esm/implementation/resource/resource-handler.d.ts

@@ -1,15 +0,0 @@
-import { OpraSchema } from '@opra/schema';
-import { nodeInspectCustom } from '../../utils/terminal-utils.js';
-import { QueryContext } from '../query-context.js';
-export declare abstract class ResourceHandler {
-    protected readonly _args: OpraSchema.Resource & {
-        prepare?: Function;
-    };
-    protected constructor(args: OpraSchema.Resource);
-    get name(): string;
-    get description(): string | undefined;
-    toString(): string;
-    prepare(ctx: QueryContext): Promise<void>;
-    abstract execute(ctx: QueryContext): Promise<void>;
-    [nodeInspectCustom](): string;
-}

package/esm/implementation/resource/resource-handler.js

@@ -1,27 +0,0 @@
-import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../../utils/terminal-utils.js';
-export class ResourceHandler {
-    _args;
-    constructor(args) {
-        this._args = args;
-    }
-    get name() {
-        return this._args.name;
-    }
-    get description() {
-        return this._args.description;
-    }
-    toString() {
-        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
-    }
-    async prepare(ctx) {
-        const { query } = ctx;
-        const fn = this._args['pre_' + query.queryType];
-        if (fn && typeof fn === 'function') {
-            await fn(ctx);
-        }
-    }
-    [nodeInspectCustom]() {
-        return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
-            ` ${colorFgMagenta + this.name + colorReset}]`;
-    }
-}

package/esm/implementation/schema-generator.d.ts

@@ -1,21 +0,0 @@
-import { StrictOmit, Type } from 'ts-gems';
-import { OpraSchema } from '@opra/schema';
-import { ThunkAsync } from '../types.js';
-export declare namespace SchemaGenerator {
-    type GenerateDocumentArgs = StrictOmit<OpraSchema.Document, 'version' | 'types'> & {
-        types?: ThunkAsync<Type | OpraSchema.DataType>[];
-    };
-    type GenerateServiceArgs = StrictOmit<OpraSchema.Service, 'version' | 'types' | 'resources'> & {
-        types?: ThunkAsync<Type | OpraSchema.DataType>[];
-        resources: any[];
-    };
-}
-export declare class SchemaGenerator {
-    protected _dataTypes: Record<string, OpraSchema.DataType>;
-    protected _resources: Record<string, OpraSchema.Resource>;
-    protected constructor();
-    protected addDataType(thunk: ThunkAsync<Type | OpraSchema.DataType>): Promise<OpraSchema.DataType>;
-    addResource(instance: any): Promise<void>;
-    static generateDocumentSchema(args: SchemaGenerator.GenerateDocumentArgs): Promise<OpraSchema.Document>;
-    static generateServiceSchema(args: SchemaGenerator.GenerateServiceArgs): Promise<OpraSchema.Service>;
-}

package/esm/implementation/schema-generator.js

@@ -1,159 +0,0 @@
-import { isPromise } from 'util/types';
-import { DATATYPE_METADATA, DATATYPE_PROPERTIES, OpraSchema } from '@opra/schema';
-import { RESOURCE_METADATA } from '../constants.js';
-import { isConstructor, resolveClassAsync } from '../utils/class-utils.js';
-import { builtinClassMap, internalDataTypes, primitiveDataTypeNames } from '../utils/internal-data-types.js';
-var isDataType = OpraSchema.isDataType;
-const entityMethods = ['search', 'count', 'create', 'get', 'update', 'updateMany', 'delete', 'deleteMany'];
-export class SchemaGenerator {
-    _dataTypes = {};
-    _resources = {};
-    constructor() {
-        //
-    }
-    async addDataType(thunk) {
-        thunk = isPromise(thunk) ? await thunk : thunk;
-        if (typeof thunk === 'function') {
-            if (!isConstructor(thunk))
-                return this.addDataType(await thunk());
-            if (builtinClassMap.has(thunk))
-                return this.addDataType(builtinClassMap.get(thunk));
-            const ctor = thunk;
-            const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, ctor);
-            if (!metadata)
-                throw new TypeError(`Class "${ctor}" has no type metadata`);
-            // Add base data type
-            let base;
-            let baseCtor = Object.getPrototypeOf(ctor);
-            if (Reflect.hasMetadata(DATATYPE_METADATA, baseCtor)) {
-                while (!Reflect.hasOwnMetadata(DATATYPE_METADATA, baseCtor)) {
-                    baseCtor = Object.getPrototypeOf(baseCtor);
-                }
-                const baseSchema = await this.addDataType(baseCtor);
-                base = baseSchema.name;
-            }
-            const schema = {
-                ...metadata,
-                ctor,
-                base
-            };
-            const properties = Reflect.getMetadata(DATATYPE_PROPERTIES, ctor.prototype);
-            if (properties) {
-                for (const [k, p] of Object.entries(properties)) {
-                    let type = p.type || 'string';
-                    if (typeof type !== 'string') {
-                        const propSchema = await this.addDataType(type);
-                        type = propSchema.name;
-                    }
-                    else {
-                        if (internalDataTypes.has(type))
-                            await this.addDataType(internalDataTypes.get(type));
-                    }
-                    schema.properties = schema.properties || {};
-                    schema.properties[k] = { ...p, type };
-                }
-            }
-            return this.addDataType(schema);
-        }
-        if (!isDataType(thunk))
-            throw new TypeError(`Invalid data type schema`);
-        // Check if datatype previously added
-        const currentSchema = this._dataTypes[thunk.name];
-        if (currentSchema) {
-            if (!(currentSchema.kind === thunk.kind && currentSchema.ctor && currentSchema.ctor === thunk.ctor))
-                throw new Error(`An other instance of "${currentSchema.name}" data type previously defined`);
-            return currentSchema;
-        }
-        if (OpraSchema.isSimpleType(thunk) && !primitiveDataTypeNames.includes(thunk.type))
-            throw new Error(`"type" of SimpleType schema must be one of enumerated value (${primitiveDataTypeNames})`);
-        return this._dataTypes[thunk.name] = {
-            ...thunk
-        };
-    }
-    async addResource(instance) {
-        if (isConstructor(instance))
-            throw new Error(`You should provide Resource instance instead of Resource class`);
-        const proto = Object.getPrototypeOf(instance);
-        const ctor = proto.constructor;
-        const metadata = Reflect.getMetadata(RESOURCE_METADATA, ctor);
-        let resourceSchema;
-        if (metadata) {
-            const name = metadata.name || ctor.name.replace(/Resource$/, '');
-            const t = typeof metadata.type === 'function'
-                ? await resolveClassAsync(metadata.type)
-                : metadata.type;
-            const type = typeof t === 'function'
-                ? (await this.addDataType(t)).name
-                : t;
-            resourceSchema = {
-                ...metadata,
-                type,
-                name,
-                instance
-            };
-            if (OpraSchema.isEntityResource(resourceSchema)) {
-                for (const methodName of entityMethods) {
-                    let fn = instance['pre_' + methodName];
-                    if (typeof fn === 'function')
-                        resourceSchema['pre_' + methodName] = fn.bind(instance);
-                    fn = instance[methodName];
-                    if (typeof fn === 'function')
-                        resourceSchema[methodName] = fn.bind(instance);
-                }
-            }
-        }
-        else
-            resourceSchema = instance;
-        if (OpraSchema.isResource(resourceSchema)) {
-            if (OpraSchema.isEntityResource(resourceSchema)) {
-                const t = this._dataTypes[resourceSchema.type];
-                if (!t)
-                    throw new Error(`Resource registration error. Type "${resourceSchema.type}" not found.`);
-                if (this._resources[resourceSchema.name])
-                    throw new Error(`An other instance of "${resourceSchema.name}" resource previously defined`);
-                this._resources[resourceSchema.name] = resourceSchema;
-                return;
-            }
-            throw new Error(`Invalid resource metadata`);
-        }
-        throw new Error(`Invalid resource object`);
-    }
-    static async generateDocumentSchema(args) {
-        const generator = new SchemaGenerator();
-        if (args.types) {
-            for (const thunk of args.types) {
-                await generator.addDataType(thunk);
-            }
-        }
-        const types = Object.keys(generator._dataTypes).sort()
-            .map(name => generator._dataTypes[name]);
-        return {
-            version: '1',
-            ...args,
-            types
-        };
-    }
-    static async generateServiceSchema(args) {
-        const generator = new SchemaGenerator();
-        if (args.types) {
-            for (const thunk of args.types) {
-                await generator.addDataType(thunk);
-            }
-        }
-        if (args.resources) {
-            for (const resource of args.resources) {
-                await generator.addResource(resource);
-            }
-        }
-        const types = Object.keys(generator._dataTypes).sort()
-            .map(name => generator._dataTypes[name]);
-        const resources = Object.keys(generator._resources).sort()
-            .map(name => generator._resources[name]);
-        return {
-            version: '1',
-            ...args,
-            types,
-            resources
-        };
-    }
-}

package/esm/interfaces/opra-schema.metadata.d.ts

@@ -1,14 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { OpraSchema } from '@opra/schema';
-import { TypeThunkAsync } from '../types.js';
-export declare type EntityResourceMetadata = StrictOmit<OpraSchema.EntityResource, 'type' | 'name'> & {
-    type: TypeThunkAsync | string;
-    name?: string;
-};
-export declare type ResourceReadOperationMetadata = StrictOmit<OpraSchema.ResourceReadOperation, 'handler'>;
-export declare type ResourceSearchOperationMetadata = StrictOmit<OpraSchema.ResourceSearchOperation, 'handler'>;
-export declare type ResourceCreateOperationMetadata = StrictOmit<OpraSchema.ResourceCreateOperation, 'handler'>;
-export declare type ResourceUpdateOperationMetadata = StrictOmit<OpraSchema.ResourceUpdateOperation, 'handler'>;
-export declare type ResourcePatchOperationMetadata = StrictOmit<OpraSchema.ResourcePatchOperation, 'handler'>;
-export declare type ResourceDeleteOperationMetadata = StrictOmit<OpraSchema.ResourceDeleteOperation, 'handler'>;
-export declare type ResourceExecuteOperationMetadata = StrictOmit<OpraSchema.ResourceExecuteOperation, 'handler'>;

package/esm/interfaces/opra-schema.metadata.js

@@ -1 +0,0 @@
-export {};

package/esm/interfaces/resource-container.interface.d.ts

@@ -1,6 +0,0 @@
-import { EntityResourceHandler } from '../implementation/resource/entity-resource-handler.js';
-import { ResourceHandler } from '../implementation/resource/resource-handler.js';
-export interface IResourceContainer {
-    getResource<T extends ResourceHandler>(name: string): T;
-    getEntityResource(name: string): EntityResourceHandler;
-}

package/esm/interfaces/resource-container.interface.js

@@ -1 +0,0 @@
-export {};

package/esm/utils/class-utils.d.ts

@@ -1,6 +0,0 @@
-import { Type } from 'ts-gems';
-import { TypeThunk, TypeThunkAsync } from '../types.js';
-export declare function isConstructor(obj: any): obj is Type;
-export declare function resolveClass<T>(typeOrFunc: TypeThunk<T>): Type<T>;
-export declare function resolveClassAsync<T>(typeOrFunc: TypeThunkAsync<T>): Promise<Type<T>>;
-export declare function isInternalClass(t: any): boolean;

package/esm/utils/class-utils.js

@@ -1,30 +0,0 @@
-const knownInternalClasses = [String, Number, Boolean, Date];
-export function isConstructor(obj) {
-    return typeof obj === 'function' &&
-        !!(obj.prototype && obj.prototype.constructor);
-}
-export function resolveClass(typeOrFunc) {
-    if (typeof typeOrFunc === 'function' && !isConstructor(typeOrFunc)) {
-        typeOrFunc = typeOrFunc();
-        if (isConstructor(typeOrFunc))
-            return typeOrFunc;
-        throw new TypeError(`Function must return a constructor`);
-    }
-    if (isConstructor(typeOrFunc))
-        return typeOrFunc;
-    throw new TypeError(`${typeOrFunc} is not a constructor`);
-}
-export async function resolveClassAsync(typeOrFunc) {
-    if (typeof typeOrFunc === 'function' && !isConstructor(typeOrFunc)) {
-        typeOrFunc = await typeOrFunc();
-        if (isConstructor(typeOrFunc))
-            return typeOrFunc;
-        throw new TypeError(`Function must return a constructor`);
-    }
-    if (isConstructor(typeOrFunc))
-        return typeOrFunc;
-    throw new TypeError(`${typeOrFunc} is not a constructor`);
-}
-export function isInternalClass(t) {
-    return knownInternalClasses.includes(t) || Buffer.isBuffer(t);
-}

package/esm/utils/headers.d.ts

@@ -1,9 +0,0 @@
-import { Opaque } from 'ts-gems';
-export declare type HeadersObject = Opaque<Record<string, any>, 'HeadersObject'>;
-/**
- * Create a proxy that ensures header keys are always formatted according to well known header names
- */
-export declare namespace Headers {
-    function from(obj: object): HeadersObject;
-    function create(): HeadersObject;
-}

package/esm/utils/headers.js

@@ -1,55 +0,0 @@
-import { HttpHeaders } from '../enums/index.js';
-const wellKnownHeaders = Object.values(HttpHeaders)
-    .reduce((target, k) => {
-    target[k.toLowerCase()] = k;
-    return target;
-}, {});
-const wrapKey = (prop) => {
-    return typeof prop == 'string' ? wellKnownHeaders[prop.toLowerCase()] || prop : prop;
-};
-/**
- * Create a proxy that ensures header keys are always formatted according to well known header names
- */
-export var Headers;
-(function (Headers) {
-    function from(obj) {
-        const headers = create();
-        for (const [k, v] of Object.entries(obj))
-            headers[k] = v;
-        return headers;
-    }
-    Headers.from = from;
-    function create() {
-        return new Proxy({}, {
-            set: (target, prop, value, receiver) => {
-                let key = prop;
-                if (typeof key === 'string')
-                    key = wellKnownHeaders[key.toLowerCase()] || key;
-                const result = Reflect.set(target, key, value, receiver);
-                /*  istanbul ignore next */
-                if (!result && Object.isFrozen(target))
-                    throw new TypeError('Cannot add property, object is not extensible');
-                return result;
-            },
-            get: (target, prop, receiver) => {
-                return Reflect.get(target, wrapKey(prop), receiver);
-            },
-            deleteProperty: (target, prop) => {
-                return Reflect.deleteProperty(target, wrapKey(prop));
-            },
-            defineProperty: (target, prop, descriptor) => {
-                let key = prop;
-                if (typeof key === 'string')
-                    key = wellKnownHeaders[key.toLowerCase()] || key;
-                return Reflect.defineProperty(target, key, descriptor);
-            },
-            getOwnPropertyDescriptor: (target, prop) => {
-                return Reflect.getOwnPropertyDescriptor(target, wrapKey(prop));
-            },
-            has: (target, prop) => {
-                return Reflect.has(target, wrapKey(prop));
-            }
-        });
-    }
-    Headers.create = create;
-})(Headers || (Headers = {}));

package/esm/utils/internal-data-types.d.ts

@@ -1,5 +0,0 @@
-import { Type } from 'ts-gems';
-import { OpraSchema } from '@opra/schema';
-export declare const primitiveDataTypeNames: string[];
-export declare const builtinClassMap: Map<Type<any>, OpraSchema.DataType>;
-export declare const internalDataTypes: Map<string, OpraSchema.DataType>;

package/esm/utils/internal-data-types.js

@@ -1,78 +0,0 @@
-export const primitiveDataTypeNames = ['boolean', 'number', 'string', 'null'];
-export const builtinClassMap = new Map();
-export const internalDataTypes = new Map();
-const internalDataTypeArray = [
-    {
-        kind: 'SimpleType',
-        name: 'boolean',
-        type: 'boolean',
-        description: 'Simple true/false value',
-        ctor: Boolean
-    },
-    {
-        kind: 'SimpleType',
-        name: 'string',
-        type: 'string',
-        description: 'A sequence of characters',
-        ctor: String
-    },
-    {
-        kind: 'SimpleType',
-        name: 'number',
-        type: 'number',
-        description: 'Both Integer as well as Floating-Point numbers',
-        ctor: Number
-    },
-    {
-        kind: 'SimpleType',
-        name: 'integer',
-        type: 'number',
-        base: 'number',
-        description: 'Integer number',
-        ctor: Number
-    },
-    {
-        kind: 'ComplexType',
-        name: 'object',
-        description: 'Object type with additional properties',
-        additionalProperties: true,
-        ctor: Object
-    },
-    {
-        kind: 'SimpleType',
-        name: 'date',
-        type: 'string',
-        description: 'Date',
-        format: 'date',
-        ctor: Date
-    },
-    {
-        kind: 'SimpleType',
-        name: 'date-time',
-        type: 'string',
-        description: 'Date time value',
-        format: 'date-time',
-        ctor: Date
-    },
-    {
-        kind: 'SimpleType',
-        name: 'time',
-        type: 'string',
-        description: 'Time value',
-        format: 'time',
-        ctor: String
-    },
-    {
-        kind: 'SimpleType',
-        name: 'buffer',
-        type: 'string',
-        description: 'Buffer value',
-        format: 'base64',
-        ctor: Buffer
-    }
-];
-internalDataTypeArray.forEach(sch => {
-    internalDataTypes.set(sch.name, sch);
-    if (sch.ctor && !builtinClassMap.has(sch.ctor))
-        builtinClassMap.set(sch.ctor, sch);
-});

package/esm/utils/responsive-object.d.ts

@@ -1,3 +0,0 @@
-import { Opaque } from 'ts-gems';
-export declare type ResponsiveObject<T> = Opaque<Record<string, T>, 'ResponsiveObject'>;
-export declare function Responsive<T>(wrapped?: Record<string, T>): ResponsiveObject<T>;

package/esm/utils/responsive-object.js

@@ -1,45 +0,0 @@
-export function Responsive(wrapped) {
-    wrapped = wrapped || {};
-    const keyMap = {};
-    Object.keys(wrapped).forEach(k => keyMap[k.toLowerCase()] = k);
-    const wrapKey = (prop) => {
-        return typeof prop == 'string' ? keyMap[prop.toLowerCase()] : prop;
-    };
-    return new Proxy(wrapped, {
-        set: (target, prop, value, receiver) => {
-            let key = prop;
-            if (typeof key === 'string') {
-                const keyLower = key.toLowerCase();
-                key = keyMap[keyLower] = keyMap[keyLower] || key;
-            }
-            const result = Reflect.set(target, key, value, receiver);
-            if (!result && Object.isFrozen(target))
-                throw new TypeError('Cannot add property, object is not extensible');
-            return result;
-        },
-        get: (target, prop, receiver) => {
-            return Reflect.get(target, wrapKey(prop), receiver);
-        },
-        deleteProperty: (target, prop) => {
-            const key = wrapKey(prop);
-            if (typeof prop === 'string') {
-                delete keyMap[prop.toLowerCase()];
-            }
-            return Reflect.deleteProperty(target, key);
-        },
-        defineProperty: (target, prop, descriptor) => {
-            let key = prop;
-            if (typeof key === 'string') {
-                const keyLower = key.toLowerCase();
-                key = keyMap[keyLower] = keyMap[keyLower] || key;
-            }
-            return Reflect.defineProperty(target, key, descriptor);
-        },
-        getOwnPropertyDescriptor: (target, prop) => {
-            return Reflect.getOwnPropertyDescriptor(target, wrapKey(prop));
-        },
-        has: (target, prop) => {
-            return Reflect.has(target, wrapKey(prop));
-        }
-    });
-}

package/esm/utils/string-path-to-object-tree.d.ts

@@ -1,4 +0,0 @@
-export interface ObjectTree {
-    [key: string]: boolean | ObjectTree;
-}
-export declare function stringPathToObjectTree(arr: string[]): ObjectTree | undefined;

package/esm/utils/terminal-utils.d.ts

@@ -1,4 +0,0 @@
-export declare const nodeInspectCustom: unique symbol;
-export declare const colorReset = "\u001B[0m";
-export declare const colorFgYellow = "\u001B[33m";
-export declare const colorFgMagenta = "\u001B[35m";

package/esm/utils/terminal-utils.js

@@ -1,4 +0,0 @@
-export const nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
-export const colorReset = "\x1b[0m";
-export const colorFgYellow = "\x1b[33m";
-export const colorFgMagenta = "\x1b[35m";