@squared-functions/types - npm Package Compare versions

Comparing version 0.12.0 to 0.13.0

lib/chrome.d.ts

 /// <reference path="type.d.ts" />
 
+import type { AttributeMap, ElementAction } from './squared';
+
 export type UnusedStyles = string[];
 
-export interface ChromeAsset {
-    rootDir?: string;
+export interface ChromeAsset extends ElementAction {
     format?: string;
     preserve?: boolean;
     exclude?: boolean;
-    outerHTML?: string;
     inlineContent?: string;
-    attributes?: ObjectMap<Undef<Null<string>>>;
+    attributes?: AttributeMap;
 }
@@ -14,0 +14,0 @@

lib/index.d.ts

@@ -5,228 +5,44 @@ /// <reference path="type.d.ts" />
 
-import type { BundleAction, CloudDatabase, CloudService, CloudStorage, CloudStorageAdmin, CloudStorageDownload, CloudStorageUpload, CompressFormat, FileAsset, RequestData, ResponseData } from './squared';
-import type * as chrome from './chrome';
+import type { CompressFormat, CompressLevel, LocationUri, ResponseData, XmlTagNode } from './squared';
 
-import type { WriteStream } from 'fs';
-import type { Response } from 'express';
-import type { BackgroundColor, ForegroundColor } from 'chalk';
+import type { ExternalAsset, FileData, FileOutput, OutputData } from './asset';
+import type { CloudDatabase, CloudFeatures, CloudFunctions, CloudService, CloudStorage, CloudStorageDownload, CloudStorageUpload } from './cloud';
+import type { CompressTryFileMethod, CompressTryImageCallback } from './compress';
+import type { ConfigOrTransformer, PluginConfig, SourceMapInput, SourceMapOptions, SourceMapOutput, TransformOutput, TransformResult } from './document';
+import type { CompleteAsyncTaskCallback, InstallData, PerformAsyncTaskMethod } from './filemanager';
+import type { CropData, QualityData, ResizeData, RotateData } from './image';
+import type { LOG_TYPE, LogMessageOptions, LogValue, ModuleFormatMessageMethod, ModuleWriteFailMethod } from './logger';
+import type { CloudModule, DocumentModule } from './module';
+import type { PermissionSettings, RequestBody, Settings } from './node';
 
-type BoolString = boolean | string;
+import type { PathLike, WriteStream } from 'fs';
+import type { FileTypeResult } from 'file-type';
 
-type FileData = functions.internal.FileData;
-type LogMessageOptions = functions.internal.LogMessageOptions;
-type FinalizeState = functions.internal.Cloud.FinalizeState;
-type ResizeData = functions.internal.Image.ResizeData;
-type CropData = functions.internal.Image.CropData;
-type RotateData = functions.internal.Image.RotateData;
-type QualityData = functions.internal.Image.QualityData;
-type SourceMapInput = functions.internal.Document.SourceMapInput;
-type SourceMapOutput = functions.internal.Document.SourceMapOutput;
-type ConfigOrTransformer = functions.internal.Document.ConfigOrTransformer
-
 declare namespace functions {
-    type CloudFeatures = "storage" | "database";
-    type CloudFunctions = "upload" | "download";
-    type ModuleWriteFailMethod = (value: string | [string, string], message?: unknown) => void;
-    type FileManagerQueueImageMethod = (data: FileData, ouputType: string, saveAs: string, command?: string) => Undef<string>;
-    type FileManagerFinalizeImageMethod<T = void> = (data: internal.Image.OutputData, error?: Null<Error>) => T;
-    type FileManagerPerformAsyncTaskCallback = VoidFunction;
-    type FileManagerCompleteAsyncTaskCallback = (value?: unknown, parent?: ExternalAsset) => void;
-    type CompressTryFileMethod = (localUri: string, data: CompressFormat, initialize?: Null<FileManagerPerformAsyncTaskCallback>, callback?: FileManagerCompleteAsyncTaskCallback) => void;
-    type CompressTryImageCallback = (success?: boolean) => void;
-
-    namespace internal {
-        namespace Image {
-            interface OutputData extends FileData {
-                output: string;
-                command: string;
-                baseDirectory?: string;
-            }
-
-            interface RotateData {
-                values: number[];
-                color: number;
-            }
-
-            interface ResizeData extends Dimension {
-                mode: string;
-                color: number;
-                align: Undef<string>[];
-                algorithm?: string;
-            }
-
-            interface CropData extends Point, Dimension {}
-
-            interface QualityData {
-                value: number;
-                nearLossless: number;
-                preset?: string;
-            }
-        }
-
-        namespace Document {
-            interface InstallData {
-                document: IDocument;
-                instance: DocumentConstructor;
-                params: unknown[];
-            }
-
-            interface SourceMapInput {
-                file: ExternalAsset;
-                sourcesContent: Null<string>;
-                sourceMap: Map<string, SourceMapOutput>;
-                map?: SourceMap;
-                nextMap: (name: string, map: SourceMap | string, value: string, includeSources?: boolean) => boolean;
-            }
-
-            interface SourceMapOutput {
-                value: string;
-                map: SourceMap;
-                sourcesContent: Null<string>;
-                url?: string;
-            }
-
-            interface SourceMap {
-                version: number;
-                sources: string[];
-                names: string[];
-                mappings: string;
-                file?: string;
-                sourceRoot?: string;
-                sourcesContent?: Null<string>[];
-            }
-
-            type Transformer = FunctionType<Undef<string>>;
-            type ConfigOrTransformer = StandardMap | Transformer;
-            type PluginConfig = [string, Undef<ConfigOrTransformer>, Undef<StandardMap>] | [];
-        }
-
-        namespace Cloud {
-            type InstanceHost = ICloud | IFileManager;
-
-            interface CacheTimeout {
-                aws?: number;
-                azure?: number;
-                gcloud?: number;
-                ibm?: number;
-                oci?: number;
-            }
-
-            interface FunctionData {
-                admin?: CloudStorageAdmin;
-                bucket?: string;
-                bucketGroup?: string;
-            }
-
-            interface UploadData extends FunctionData {
-                upload: CloudStorageUpload;
-                buffer: Buffer;
-                localUri: string;
-                fileGroup: [Buffer | string, string][];
-                filename?: string;
-                mimeType?: string;
-            }
-
-            interface DownloadData extends FunctionData {
-                download: CloudStorageDownload;
-            }
-
-            interface FinalizeState {
-                manager: IFileManager;
-                cloud: ICloud;
-                bucketGroup: string;
-                localStorage: Map<ExternalAsset, CloudStorageUpload>;
-                compressed: ExternalAsset[];
-            }
-
-            interface ServiceClient {
-                validateStorage?(credential: PlainObject, data?: CloudService): boolean;
-                validateDatabase?(credential: PlainObject, data?: CloudService): boolean;
-                createStorageClient?<T>(this: InstanceHost, credential: unknown, service?: string): T;
-                createDatabaseClient?<T>(this: InstanceHost, credential: unknown, data?: CloudService): T;
-                createBucket?(this: InstanceHost, credential: unknown, bucket: string, publicRead?: boolean, service?: string, sdk?: string): Promise<boolean>;
-                deleteObjects?(this: InstanceHost, credential: unknown, bucket: string, service?: string, sdk?: string): Promise<void>;
-                executeQuery?(this: ICloud, credential: unknown, data: CloudDatabase, cacheKey?: string): Promise<PlainObject[]>;
-            }
-
-            interface FinalizeResult {
-                compressed: ExternalAsset[];
-            }
-
-            type ServiceHost<T> = (this: InstanceHost, credential: unknown, service?: string, sdk?: string) => T;
-            type UploadHost = ServiceHost<UploadCallback>;
-            type DownloadHost = ServiceHost<DownloadCallback>;
-            type UploadCallback = (data: UploadData, success: (value: string) => void) => Promise<void>;
-            type DownloadCallback = (data: DownloadData, success: (value: Null<Buffer | string>) => void) => Promise<void>;
-        }
-
-        interface DocumentData {
-            document?: string[];
-        }
-
-        interface FileData {
-            file: ExternalAsset;
-            mimeType?: string | false;
-        }
-
-        interface FileOutput {
-            pathname: string;
-            localUri: string;
-        }
-
-        enum LOG_TYPE {
-            UNKNOWN = 0,
-            SYSTEM = 1,
-            NODE = 2,
-            PROCESS = 4,
-            COMPRESS = 8,
-            WATCH = 16,
-            CLOUD_STORAGE = 32,
-            CLOUD_DATABASE = 64,
-            TIME_ELAPSED = 128
-        }
-
-        interface LogMessageOptions {
-            titleColor?: typeof ForegroundColor;
-            titleBgColor?: typeof BackgroundColor;
-            valueColor?: typeof ForegroundColor;
-            valueBgColor?: typeof BackgroundColor;
-            hintColor?: typeof ForegroundColor;
-            hintBgColor?: typeof BackgroundColor;
-            messageColor?: typeof ForegroundColor;
-            messageBgColor?: typeof BackgroundColor;
-        }
+    interface IScopeOrigin<T = IModule, U = IModule> {
+        host?: T;
+        instance: U;
     }
 
-    interface INode extends IModule {
-        setDiskRead(): void;
-        setDiskWrite(): void;
-        setUNCRead(): void;
-        setUNCWrite(): void;
-        hasDiskRead(): boolean;
-        hasDiskWrite(): boolean;
-        hasUNCRead(): boolean;
-        hasUNCWrite(): boolean;
-        isFileURI(value: string): boolean;
-        isFileUNC(value: string): boolean;
-        isDirectoryUNC(value: string): boolean;
-        isUUID(value: string): boolean;
-        getResponseError(hint: string, message: Error | string): ResponseData;
-        resolvePath(value: string, href: string): string;
-    }
-
     interface ICompress extends IModule {
-        gzipLevel: number;
-        brotliQuality: number;
-        tinifyApiKey: string;
-        compressorProxy: ObjectMap<CompressTryFileMethod>;
+        level: ObjectMap<number>;
+        compressors: ObjectMap<CompressTryFileMethod>;
+        chunkSize?: number;
         register(format: string, callback: CompressTryFileMethod): void;
-        createWriteStreamAsGzip(source: string, localUri: string, level?: number): WriteStream;
-        createWriteStreamAsBrotli(source: string, localUri: string, quality?: number, mimeType?: string): WriteStream;
-        findFormat(compress: Undef<CompressFormat[]>, format: string): Undef<CompressFormat>;
-        withinSizeRange(localUri: string, value: Undef<string>): boolean;
+        createWriteStreamAsGzip(uri: string, output: string, options?: CompressLevel): WriteStream;
+        createWriteStreamAsBrotli(uri: string, output: string, options?: CompressLevel): WriteStream;
         tryFile: CompressTryFileMethod;
-        tryImage(localUri: string, data: CompressFormat, callback: CompressTryImageCallback): void;
+        tryImage(uri: string, data: CompressFormat, callback: CompressTryImageCallback): void;
     }
 
     interface IImage extends IModule {
+        resizeData?: ResizeData;
+        cropData?: CropData;
+        rotateData?: RotateData;
+        qualityData?: QualityData;
+        opacityValue: number;
+        readonly moduleName: string;
+        reset(): void;
+        setCommand(value: string): void;
+        getCommand(): string;
         parseMethod(value: string): Undef<string[]>;
@@ -241,31 +57,21 @@ parseResize(value: string): Undef<ResizeData>;
     interface ImageConstructor extends ModuleConstructor {
-        resolveMime(this: IFileManager, data: FileData): Promise<boolean>;
-        using(this: IFileManager, data: FileData, command: string, callback?: FileManagerFinalizeImageMethod): void;
+        using(this: IFileManager, data: FileData, command: string): void;
+        transform(uri: string, command: string, mimeType?: string, tempFile?: boolean): Promise<Null<Buffer> | string>;
+        parseFormat(command: string): string[];
+        clamp(value: Undef<string>, min?: number, max?: number): number;
         new(): IImage;
     }
 
-    const Image: ImageConstructor;
+    interface ITask extends IModule {
+        module: DocumentModule;
+        execute?(manager: IFileManager, task: PlainObject, callback: (value?: unknown) => void): void;
+    }
 
-    class ImageCommand<T> {
-        instance: T;
-        command: string
-        resizeData?: ResizeData;
-        cropData?: CropData;
-        rotateData?: RotateData;
-        qualityData?: QualityData;
-        opacityValue: number;
-        errorHandler?: (err: Error) => void;
-        method(): void;
-        resize(): void;
-        crop(): void;
-        opacity(): void;
-        quality(): void;
-        rotate(initialize?: FileManagerPerformAsyncTaskCallback, callback?: FileManagerCompleteAsyncTaskCallback): void;
-        write(output: string, startTime?: number, callback?: FileManagerFinalizeImageMethod): void;
-        finalize(output: string, callback: (result: string) => void): void;
-        constructor(instance: T, data: FileData, command: string, finalAs?: string);
+    interface TaskConstructor extends ModuleConstructor {
+        using(this: IFileManager, task: ITask, assets: ExternalAsset[], beforeStage?: boolean): Promise<void>;
+        new(module: DocumentModule): ITask;
     }
 
     interface ICloud extends IModule {
-        settings: ExtendedSettings.CloudModule;
+        settings: CloudModule;
         database: CloudDatabase[];
@@ -285,45 +91,52 @@ compressFormat: Set<string>;
         getCredential(data: CloudService): PlainObject;
-        getUploadHandler(service: string, credential: unknown): internal.Cloud.UploadCallback;
-        getDownloadHandler(service: string, credential: unknown): internal.Cloud.DownloadCallback;
+        getUploadHandler(service: string, credential: unknown): FunctionType<Promise<void>>;
+        getDownloadHandler(service: string, credential: unknown): FunctionType<Promise<void>>;
     }
 
     interface CloudConstructor extends ModuleConstructor {
-        finalize(this: IFileManager, cloud: ICloud): Promise<internal.Cloud.FinalizeResult>;
-        uploadAsset(this: IFileManager, cloud: ICloud, state: FinalizeState, file: ExternalAsset, mimeType?: string, uploadDocument?: boolean): Promise<void>;
-        new(settings: ExtendedSettings.CloudModule): ICloud;
+        finalize<T = IFileManager, U = ICloud>(this: T, instance: U): Promise<void>;
+        uploadAsset<T = IFileManager, U = ICloud>(this: T, instance: U, state: IScopeOrigin<T, U>, file: ExternalAsset, mimeType?: string, uploadDocument?: boolean): Promise<void>;
+        new(settings: CloudModule): ICloud;
     }
 
-    const Cloud: CloudConstructor;
+    interface ICloudServiceClient {
+        validateStorage?(credential: PlainObject, data?: CloudService): boolean;
+        validateDatabase?(credential: PlainObject, data?: CloudService): boolean;
+        createStorageClient?<T>(this: IModule, credential: unknown, service?: string): T;
+        createDatabaseClient?<T>(this: IModule, credential: unknown, data?: CloudService): T;
+        createBucket?(this: IModule, credential: unknown, bucket: string, publicRead?: boolean, service?: string, sdk?: string): Promise<boolean>;
+        deleteObjects?(this: IModule, credential: unknown, bucket: string, service?: string, sdk?: string): Promise<void>;
+        executeQuery?(this: ICloud, credential: unknown, data: CloudDatabase, cacheKey?: string): Promise<PlainObject[]>;
+    }
 
-    interface IDocument extends IModule {
-        settings: ExtendedSettings.DocumentModule;
-        documentName: string;
-        internalAssignUUID: string;
+    interface IDocument<T = IFileManager, U = ICloud> extends IModule {
+        module: DocumentModule;
+        moduleName: string;
         templateMap?: StandardMap;
-        findPluginData(type: string, name: string, settings: ObjectMap<StandardMap>): internal.Document.PluginConfig;
-        loadOptions(value: ConfigOrTransformer | string): Undef<ConfigOrTransformer>;
-        loadConfig(value: string): Undef<StandardMap | string>;
-        transform(type: string, format: string, value: string, input?: SourceMapInput): Promise<Void<[string, Undef<Map<string, SourceMapOutput>>]>>;
-        formatContent?(manager: IFileManager, document: IDocument, file: ExternalAsset, content: string): Promise<string>;
-        imageQueue?: FileManagerQueueImageMethod;
-        imageFinalize?: FileManagerFinalizeImageMethod<boolean>;
-        cloudInit?(state: FinalizeState): void;
-        cloudObject?(state: FinalizeState, file: ExternalAsset): boolean;
-        cloudUpload?(state: FinalizeState, file: ExternalAsset, url: string, active: boolean): Promise<boolean>;
-        cloudFinalize?(state: FinalizeState): Promise<void>;
+        init(assets: ExternalAsset[], body: RequestBody): void;
+        findConfig(settings: StandardMap, name: string, type?: string): PluginConfig;
+        loadConfig(data: StandardMap, name: string): Optional<ConfigOrTransformer>;
+        transform(type: string, code: string, format: string, options?: TransformOutput): Promise<Void<TransformResult>>;
+        setLocalUri?(file: Partial<LocationUri>, manager?: IFileManager): void;
+        formatContent?(file: ExternalAsset, content: string, manager?: IFileManager): Promise<string>;
+        addCopy?(data: FileData, saveAs: string, replace?: boolean, manager?: IFileManager): Undef<string>;
+        writeImage?(data: OutputData, manager?: IFileManager): boolean;
+        cloudInit?(state: IScopeOrigin<T, U>): void;
+        cloudObject?(state: IScopeOrigin<T, U>, file: ExternalAsset): boolean;
+        cloudUpload?(state: IScopeOrigin<T, U>, file: ExternalAsset, url: string, active: boolean): Promise<boolean>;
+        cloudFinalize?(state: IScopeOrigin<T, U>): Promise<void>;
     }
 
     interface DocumentConstructor extends ModuleConstructor {
-        init(this: IFileManager, document: IDocument): boolean;
-        using(this: IFileManager, document: IDocument, file: ExternalAsset): Promise<void>;
-        finalize(this: IFileManager, document: IDocument, assets: ExternalAsset[]): void;
-        new(body: RequestBody, settings?: ExtendedSettings.DocumentModule, ...args: unknown[]): IDocument;
+        using(this: IFileManager, instance: IDocument, file: ExternalAsset): Promise<void>;
+        finalize(this: IFileManager, instance: IDocument, assets: ExternalAsset[]): Promise<void>;
+        createSourceMap(code: string, file?: ExternalAsset): SourceMapInput;
+        writeSourceMap(localUri: string, sourceMap: SourceMapOutput, options?: SourceMapOptions): Undef<string>;
+        new(module: DocumentModule, templateMap?: Undef<StandardMap>, ...args: unknown[]): IDocument;
     }
 
-    const Document: DocumentConstructor;
-
     interface IWatch extends IModule {
         interval: number;
         whenModified?: (assets: ExternalAsset[]) => void;
-        start(assets: ExternalAsset[]): void;
+        start(assets: ExternalAsset[], permission?: IPermission): void;
     }
@@ -335,14 +148,28 @@
 
-    const Watch: WatchConstructor;
+    interface IPermission {
+        hasDiskRead(): boolean;
+        hasDiskWrite(): boolean;
+        hasUNCRead(): boolean;
+        hasUNCWrite(): boolean;
+    }
 
+    interface PermissionConstructor {
+        new(settings?: PermissionSettings): IFileManager;
+    }
+
     interface IFileManager extends IModule {
         delayed: number;
         cleared: boolean;
-        Document: internal.Document.InstallData[];
+        Document: InstallData<IDocument, DocumentConstructor>[];
+        Task: InstallData<ITask, TaskConstructor>[];
+        Image: Null<Map<string, ImageConstructor>>;
         Cloud: Null<ICloud>;
         Watch: Null<IWatch>;
-        Image: Null<ImageConstructor>;
         Compress: Null<ICompress>;
-        Gulp: Null<ExtendedSettings.GulpModule>;
+        readonly startTime: number;
+        readonly baseDirectory: string;
         readonly body: RequestBody;
+        readonly assets: ExternalAsset[];
+        readonly documentAssets: ExternalAsset[];
+        readonly taskAssets: ExternalAsset[];
         readonly files: Set<string>;
@@ -354,31 +181,34 @@ readonly filesQueued: Set<string>;
         readonly emptyDir: Set<string>;
-        readonly assets: ExternalAsset[];
-        readonly documentAssets: ExternalAsset[];
-        readonly postFinalize: FunctionType<void>;
-        readonly baseDirectory: string;
-        install(name: string, ...args: unknown[]): void;
-        add(value: string): void;
+        readonly permission: IPermission;
+        readonly postFinalize?: (errors: string[]) => void;
+        install(name: string, ...params: unknown[]): void;
+        add(value: string, parent?: ExternalAsset): void;
         delete(value: string, emptyDir?: boolean): void;
         has(value: Undef<string>): value is string;
         replace(file: ExternalAsset, replaceWith: string, mimeType?: string): void;
-        performAsyncTask: FileManagerPerformAsyncTaskCallback;
+        removeAsset(file: ExternalAsset): void;
+        performAsyncTask: PerformAsyncTaskMethod;
         removeAsyncTask(): void;
-        completeAsyncTask: FileManagerCompleteAsyncTaskCallback;
+        completeAsyncTask: CompleteAsyncTaskCallback;
         performFinalize(): void;
-        setLocalUri(file: ExternalAsset): internal.FileOutput;
-        getRelativePath(file: ExternalAsset, filename?: string): string;
-        assignUUID(data: internal.DocumentData, attr: string, target?: any): Undef<string>;
-        findAsset(uri: string): Undef<ExternalAsset>;
+        hasDocument(instance: IModule, document: Undef<StringOfArray>): boolean;
+        getDocumentAssets(instance: IModule): ExternalAsset[];
+        getCloudAssets(instance: IModule): CloudDatabase[];
+        getElements(): XmlTagNode[];
+        setLocalUri(file: ExternalAsset): FileOutput;
+        getLocalUri(data: FileData): string;
+        getMimeType(data: FileData): Undef<string>;
+        getRelativeUri(file: ExternalAsset, filename?: string): string;
+        findAsset(uri: string, instance?: IModule): Undef<ExternalAsset>;
         removeCwd(value: Undef<string>): string;
         getUTF8String(file: ExternalAsset, localUri?: string): string;
-        appendContent(file: ExternalAsset, localUri: string, content: string, bundleIndex?: number): Promise<string>;
-        getTrailingContent(file: ExternalAsset): Promise<string>;
-        joinAllContent(localUri: string): Undef<string>;
-        createSourceMap(file: ExternalAsset, sourcesContent: string): SourceMapInput;
-        writeSourceMap(outputData: [string, Undef<Map<string, SourceMapOutput>>], file: ExternalAsset, sourceContent?: string, modified?: boolean): void;
-        compressFile(file: ExternalAsset): Promise<unknown>;
-        queueImage: FileManagerQueueImageMethod;
-        finalizeImage: FileManagerFinalizeImageMethod;
-        finalizeAsset(data: FileData, parent?: ExternalAsset): Promise<void>;
-        processAssets(watch?: boolean): void;
+        setAssetContent(file: ExternalAsset, localUri: string, content: string, index?: number): Promise<string>;
+        getAssetContent(file: ExternalAsset): Undef<string>;
+        writeBuffer(file: ExternalAsset): Null<Buffer>;
+        writeImage(document: StringOfArray, data: OutputData): boolean;
+        compressFile(file: ExternalAsset, overwrite?: boolean): Promise<unknown>;
+        addCopy(data: FileData, saveAs?: string, replace?: boolean): Undef<string>;
+        findMime(data: FileData, rename?: boolean): Promise<string>;
+        transformAsset(data: FileData, parent?: ExternalAsset): Promise<void>;
+        processAssets(emptyDir?: boolean): void;
         finalize(): Promise<void>;
@@ -388,13 +218,11 @@ }
     interface FileManagerConstructor extends ModuleConstructor {
-        hasPermissions(dirname: string, res?: Response): boolean;
-        loadSettings(value: Settings, ignorePermissions?: boolean): void;
-        moduleNode(): INode;
+        getPermission(settings?: PermissionSettings): IPermission;
+        hasPermission(dirname: string, permission: IPermission): true | ResponseData;
         moduleCompress(): ICompress;
-        new(baseDirectory: string, body: RequestBody, postFinalize?: FunctionType<void>): IFileManager;
+        resolveMime(data: Buffer | string): Promise<Undef<FileTypeResult>>;
+        new(baseDirectory: string, body: RequestBody, postFinalize?: (errors: string[]) => void, settings?: PermissionSettings): IFileManager;
     }
 
-    const FileManager: FileManagerConstructor;
-
     interface IModule {
-        logType: typeof internal.LOG_TYPE;
+        logType: typeof LOG_TYPE;
         tempDir: string;
@@ -404,101 +232,46 @@ readonly major: number;
         readonly patch: number;
+        readonly errors: string[];
+        readonly moduleName?: string;
         supported(major: number, minor: number, patch?: number): boolean;
-        parseFunction(value: string): Null<FunctionType<string>>;
-        joinPosix(...paths: Undef<string>[]): string;
-        getTempDir(subDir?: boolean, filename?: string): string;
-        formatMessage(type: internal.LOG_TYPE, title: string, value: string | [string, string], message?: unknown, options?: LogMessageOptions): void;
-        formatFail(type: internal.LOG_TYPE, title: string, value: string | [string, string], message?: unknown): void;
+        getTempDir(uuidDir?: boolean, filename?: string): string;
+        formatMessage: ModuleFormatMessageMethod;
+        formatFail(type: LOG_TYPE, title: string, value: LogValue, message?: Null<Error>): void;
         writeFail: ModuleWriteFailMethod;
         writeTimeElapsed(title: string, value: string, time: number, options?: LogMessageOptions): void;
-        writeMessage(title: string, value: string, message?: unknown, options?: LogMessageOptions): void;
     }
 
     interface ModuleConstructor {
-        loadSettings(value: Settings): void;
-        getFileSize(localUri: string): number;
+        LOG_TYPE: typeof LOG_TYPE;
+        LOG_STYLE_FAIL: LogMessageOptions;
+        formatMessage: ModuleFormatMessageMethod;
+        writeFail: ModuleWriteFailMethod;
+        parseFunction(value: string, name?: string): Undef<FunctionType<string>>;
         toPosix(value: string, filename?: string): string;
         renameExt(value: string, ext: string): string;
-        isLocalPath(value: string): string;
-        fromSameOrigin(value: string, other: string): boolean;
+        fromLocalPath(value: string): string;
+        hasSameOrigin(value: string, other: string): boolean;
+        isFileHTTP(value: string): boolean;
+        isFileUNC(value: string): boolean;
+        isDirectoryUNC(value: string): boolean;
+        isUUID(value: string): boolean;
+        resolveUri(value: string): string;
+        resolvePath(value: string, href: string): string;
+        joinPosix(...values: Undef<string>[]): string;
+        getFileSize(value: PathLike): number;
+        loadSettings(value: Settings): void;
+        responseError(err: Error | string, hint?: string): ResponseData;
+        allSettled<T>(values: readonly (T | PromiseLike<T>)[], rejected?: string | [string, string]): Promise<PromiseSettledResult<T>[]>;
         new(): IModule;
     }
 
+    const Image: ImageConstructor;
+    const Task: TaskConstructor;
+    const Cloud: CloudConstructor;
+    const Document: DocumentConstructor;
+    const Watch: WatchConstructor;
+    const Permission: PermissionConstructor;
+    const FileManager: FileManagerConstructor;
     const Module: ModuleConstructor;
-
-    interface Settings {
-        apiVersion?: string;
-        disk_read?: BoolString;
-        disk_write?: BoolString;
-        unc_read?: BoolString;
-        unc_write?: BoolString;
-        logger?: ExtendedSettings.LoggerModule;
-        watch?: ExtendedSettings.WatchModule;
-        image?: ExtendedSettings.ImageModule;
-        compress?: ExtendedSettings.CompressModule;
-        cloud?: ExtendedSettings.CloudModule;
-        gulp?: ExtendedSettings.GulpModule;
-    }
-
-    namespace ExtendedSettings {
-        interface LoggerModule {
-            unknown?: boolean;
-            system?: boolean;
-            node?: boolean;
-            process?: boolean;
-            compress?: boolean;
-            watch?: boolean;
-            cloud_storage?: boolean;
-            cloud_database?: boolean;
-            time_elapsed?: boolean;
-        }
-
-        interface ImageModule {
-            command?: string;
-        }
-
-        interface CompressModule {
-            gzip_level?: NumString;
-            brotli_quality?: NumString;
-            tinypng_api_key?: string;
-        }
-
-        interface CloudModule {
-            cache?: Partial<internal.Cloud.CacheTimeout>;
-            aws?: ObjectMap<StringMap>;
-            azure?: ObjectMap<StringMap>;
-            gcloud?: ObjectMap<StringMap>;
-            ibm?: ObjectMap<StringMap>;
-            oci?: ObjectMap<StringMap>;
-        }
-
-        interface GulpModule extends StringMap {}
-
-        interface DocumentModule extends StandardMap {
-            eval_function?: boolean;
-            eval_template?: boolean;
-        }
-
-        interface WatchModule {
-            interval?: number;
-        }
-    }
-
-    interface RequestBody extends RequestData, chrome.RequestData {
-        assets: ExternalAsset[];
-    }
-
-    interface ExternalAsset extends FileAsset, BundleAction {
-        localUri?: string;
-        cloudUri?: string;
-        buffer?: Buffer;
-        sourceUTF8?: string;
-        relativePath?: string;
-        originalName?: string;
-        transforms?: string[];
-        etag?: string;
-        invalid?: boolean;
-    }
 }
 
-export = functions;
-export as namespace functions;
+export = functions;

lib/squared.d.ts

@@ -5,3 +5,3 @@ /// <reference path="type.d.ts" />
     watch?: boolean | WatchInterval;
-    tasks?: string[];
+    tasks?: TaskAction[];
 }
@@ -18,19 +18,15 @@
 
-interface OutputAction {
+export interface OutputAction<T = unknown> extends DocumentAction {
     moveTo?: string;
     commands?: string[];
     compress?: CompressFormat[];
-    document?: string[];
-    cloudStorage?: CloudStorage[];
+    cloudStorage?: T[];
 }
 
-export interface LocationUri {
-    pathname: string;
-    filename: string;
+export interface TaskAction {
+    handler: string;
+    task: string;
+    preceding?: boolean;
 }
 
-export interface FileAsset extends TextAsset, OutputAction {
-    base64?: string;
-}
-
 export interface BundleAction {
@@ -43,59 +39,61 @@ bundleId?: number;
 
-export interface CompressFormat {
-    format: string;
-    level?: number;
-    condition?: string;
-    plugin?: string;
-    options?: PlainObject;
+export interface DocumentAction {
+    document?: StringOfArray;
 }
 
-export interface CloudService extends ObjectMap<unknown> {
-    service: string;
-    credential: string | PlainObject;
+export interface AttributeAction {
+    attributes?: AttributeMap;
 }
 
-export interface CloudDatabase<T = string | PlainObject | any[]> extends CloudService {
-    table: string;
-    value: string | ObjectMap<string | string[]>;
-    name?: string;
+export interface ElementAction {
+    element?: XmlTagNode;
+}
+
+export interface TagData {
+    tagName: string;
+    tagCount?: number;
+    tagIndex?: number;
+}
+
+export interface TagAppend extends TagData {
+    order: number;
     id?: string;
-    query?: T;
-    limit?: number;
-    params?: unknown[];
-    options?: PlainObject;
-    element?: {
-        outerHTML?: string;
-    };
+    textContent?: string;
+    prepend?: boolean;
 }
 
-export interface CloudStorage extends CloudService {
-    bucket?: string;
-    admin?: CloudStorageAdmin;
-    upload?: CloudStorageUpload;
-    download?: CloudStorageDownload;
+export interface XmlNode extends AttributeAction {
+    index?: number;
+    outerXml?: string;
+    innerXml?: string;
+    lowerCase?: boolean;
 }
 
-export interface CloudStorageAdmin {
-    publicRead?: boolean;
-    emptyBucket?: boolean;
-    preservePath?: boolean;
+export interface XmlTagNode extends XmlNode, TagData {
+    id?: StringMap;
+    append?: TagAppend;
 }
 
-export interface CloudStorageAction extends Partial<LocationUri> {
-    active?: boolean;
-    overwrite?: boolean;
+export interface LocationUri {
+    pathname: string;
+    filename: string;
 }
 
-export interface CloudStorageUpload extends CloudStorageAction {
-    localStorage?: boolean;
-    endpoint?: string;
-    all?: boolean;
-    publicRead?: boolean;
+export interface FileAsset<T = unknown> extends TextAsset, OutputAction<T> {
+    base64?: string;
 }
 
-export interface CloudStorageDownload extends CloudStorageAction {
-    versionId?: string;
-    deleteObject?: string;
+export interface CompressLevel {
+    level?: number;
+    chunkSize?: number;
+    mimeType?: string;
 }
 
+export interface CompressFormat extends CompressLevel {
+    format: string;
+    condition?: string;
+    plugin?: string;
+    options?: PlainObject;
+}
+
 export interface WatchInterval {
@@ -106,6 +104,7 @@ interval?: number;
 
-export interface RequestData extends PlainObject {
+export interface RequestData<T = unknown> extends PlainObject {
     assets?: FileAsset[];
-    database?: CloudDatabase[];
+    database?: T[];
     document?: string[];
+    task?: string[];
 }
@@ -116,4 +115,5 @@
     data?: unknown;
-    zipname?: string;
+    filename?: string;
     downloadKey?: string;
+    downloadUrl?: string;
     bytes?: number;
@@ -127,2 +127,4 @@ files?: string[];
     hint?: string;
-}
+}
+
+export type AttributeMap = ObjectMap<Optional<string>>;

lib/type.d.ts

 type Undef<T> = T | undefined;
 type Null<T> = T | null;
 type Void<T> = T | void;
+type Optional<T> = Undef<T> | Null<T>;
 type Constructor<T> = new(...args: any[]) => T;
@@ -8,2 +9,3 @@ type FunctionType<T, U = unknown> = (...args: U[]) => T;
 type NumString = number | string;
+type StringOfArray = string | string[];
 
@@ -13,5 +15,7 @@ type StandardMap = Record<string, any>;
 type StringMap = Record<string, Undef<string>>;
-
 type ObjectMap<T> = Record<string, T>;
 
+type JsonData = Optional<string | number | boolean | unknown[] | StandardMap>;
+type StandardCallback<T = unknown, U = void> = (err: Null<Error>, result: T) => U;
+
 interface Point {
@@ -18,0 +22,0 @@ x: number;

package.json

 {
   "name": "@squared-functions/types",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Type definitions for squared-functions",
@@ -17,4 +17,4 @@ "types": "lib/index.d.ts",
   "dependencies": {
-    "typescript": "^4.1.3"
+    "typescript": "^4.1.5"
   }
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

28093

increased by5.23%

Number of package files

16

increased by128.57%

Lines of code

636

increased by10.99%

Worsened metrics

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• Updatedtypescript@^4.1.5