depflow 3.0.0-dev.1 → 3.0.0-dev.11

package/dist/schema/Config/Config.d.ts

@@ -0,0 +1,673 @@
+/**
+ * @author NetFeez <netfeez.dev@gmail.com>.
+ * @description Root configuration schema: dependencies, resolver, build actions and output paths.
+ * @license Apache-2.0
+ */
+import Schema from '@netfeez/schema';
+export declare const Config: Schema<{
+    readonly type: "object";
+    readonly keys: {
+        readonly $schema: {
+            readonly type: "string";
+            readonly default: ".depflow/schema.json";
+            readonly description: "Path to the JSON Schema describing the configuration. Used by editors and tools to provide validation, autocompletion and other features.";
+        };
+        readonly outDir: {
+            readonly type: "string";
+            readonly default: "dist";
+            readonly description: "Output directory for built files. Can be relative or absolute. Defaults to \"dist\".";
+        };
+        readonly tsconfig: {
+            readonly type: "string";
+            readonly nullable: true;
+            readonly default: null;
+            readonly description: "Path to the tsconfig.json file. Can be relative or absolute. Defaults to \"tsconfig.json\".";
+        };
+        readonly importmap: {
+            readonly type: "string";
+            readonly nullable: true;
+            readonly default: null;
+            readonly description: "Path to the importmap.json file. Can be relative or absolute. Defaults to \"importmap.json\".";
+        };
+        readonly actions: {
+            readonly type: "object";
+            readonly additional: {
+                readonly type: "array";
+                readonly default: never[];
+                readonly items: {
+                    readonly type: "union";
+                    readonly required: true;
+                    readonly union: readonly [{
+                        readonly type: "object";
+                        readonly required: true;
+                        readonly keys: {
+                            readonly maxTimeMs: {
+                                readonly type: "number";
+                                readonly default: 60000;
+                                readonly minimum: -1;
+                                readonly description: "Maximum execution time for the run step in milliseconds. A value of -1 disables the limit.";
+                            };
+                            readonly allowFails: {
+                                readonly type: "boolean";
+                                readonly default: false;
+                                readonly description: "Whether failed commands within the step are tolerated. Defaults to false.";
+                            };
+                            readonly run: {
+                                readonly type: "union";
+                                readonly required: true;
+                                readonly union: readonly [{
+                                    readonly type: "string";
+                                }, {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "string";
+                                    };
+                                }];
+                                readonly description: "Shell command or list of shell commands to execute.";
+                            };
+                        };
+                    }, {
+                        readonly type: "object";
+                        readonly required: true;
+                        readonly keys: {
+                            readonly extract: {
+                                readonly type: "union";
+                                readonly required: true;
+                                readonly union: readonly [{
+                                    readonly type: "string";
+                                }, {
+                                    readonly type: "object";
+                                    readonly required: true;
+                                    readonly additional: {
+                                        readonly type: "union";
+                                        readonly required: true;
+                                        readonly union: readonly [{
+                                            readonly type: "string";
+                                            readonly required: true;
+                                        }, {
+                                            readonly type: "object";
+                                            readonly required: true;
+                                            readonly keys: {
+                                                readonly to: {
+                                                    readonly type: "string";
+                                                    readonly required: true;
+                                                    readonly description: "Destination folder to which the matched files are copied. A relative path is resolved against the project root, an absolute one is used as it stands.";
+                                                };
+                                                readonly map: {
+                                                    readonly type: "union";
+                                                    readonly union: readonly [{
+                                                        readonly type: "string";
+                                                    }, {
+                                                        readonly type: "object";
+                                                        readonly keys: {
+                                                            readonly search: {
+                                                                readonly type: "string";
+                                                                readonly required: true;
+                                                                readonly description: "The regular expression pattern to search for in the file content.";
+                                                            };
+                                                            readonly flags: {
+                                                                readonly type: "string";
+                                                                readonly default: "g";
+                                                                readonly pattern: RegExp;
+                                                                readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
+                                                            };
+                                                            readonly replace: {
+                                                                readonly type: "string";
+                                                                readonly required: true;
+                                                                readonly description: "The replacement string used to substitute the matches found by the search pattern.";
+                                                            };
+                                                        };
+                                                    }];
+                                                    readonly required: false;
+                                                    readonly description: "Transformation applied to the destination path of the extracted files.";
+                                                };
+                                                readonly transform: {
+                                                    readonly type: "union";
+                                                    readonly union: readonly [{
+                                                        readonly type: "string";
+                                                    }, {
+                                                        readonly type: "object";
+                                                        readonly keys: {
+                                                            readonly search: {
+                                                                readonly type: "string";
+                                                                readonly required: true;
+                                                                readonly description: "The regular expression pattern to search for in the file content.";
+                                                            };
+                                                            readonly flags: {
+                                                                readonly type: "string";
+                                                                readonly default: "g";
+                                                                readonly pattern: RegExp;
+                                                                readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
+                                                            };
+                                                            readonly replace: {
+                                                                readonly type: "string";
+                                                                readonly required: true;
+                                                                readonly description: "The replacement string used to substitute the matches found by the search pattern.";
+                                                            };
+                                                        };
+                                                    }];
+                                                    readonly required: false;
+                                                    readonly description: "Transformation applied to the content of the extracted files.";
+                                                };
+                                            };
+                                        }];
+                                    };
+                                    readonly description: "Mapping of source glob patterns, relative to the folder the pipeline works in, to extraction entries, each describing where and how files are extracted.";
+                                }];
+                                readonly description: "Destination folder for the extracted files or an extraction mapping.";
+                            };
+                        };
+                    }, {
+                        readonly type: "object";
+                        readonly required: true;
+                        readonly keys: {
+                            readonly transform: {
+                                readonly type: "object";
+                                readonly required: true;
+                                readonly keys: {
+                                    readonly search: {
+                                        readonly type: "string";
+                                        readonly required: true;
+                                        readonly description: "The regular expression pattern to search for in the file content.";
+                                    };
+                                    readonly flags: {
+                                        readonly type: "string";
+                                        readonly default: "g";
+                                        readonly pattern: RegExp;
+                                        readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
+                                    };
+                                    readonly replace: {
+                                        readonly type: "string";
+                                        readonly required: true;
+                                        readonly description: "The replacement string used to substitute the matches found by the search pattern.";
+                                    };
+                                    readonly glob: {
+                                        readonly type: "string";
+                                        readonly required: true;
+                                        readonly description: "Glob pattern matching the files to which the global transformation is applied.";
+                                    };
+                                };
+                                readonly description: "Global transformation to apply over the files matched by the glob pattern.";
+                            };
+                        };
+                    }];
+                    readonly description: "A single build step: run commands, extract files or apply a global transformation.";
+                };
+                readonly description: "Ordered pipeline of build steps applied when a dependency is built.";
+            };
+            readonly default: Record<string, never>;
+            readonly description: "Named build actions. Each action runs a pipeline of run, extract and transform steps.";
+        };
+        readonly resolver: {
+            readonly type: "object";
+            readonly required: true;
+            readonly additional: {
+                readonly type: "union";
+                readonly required: true;
+                readonly union: readonly [{
+                    readonly type: "string";
+                }, {
+                    readonly type: "object";
+                    readonly keys: {
+                        readonly local: {
+                            readonly type: "string";
+                            readonly required: true;
+                            readonly description: "Local path or glob pattern the dependency resolves to.";
+                        };
+                        readonly type: {
+                            readonly type: "string";
+                            readonly description: "Optional identifier describing the resolution type.";
+                        };
+                        readonly cdn: {
+                            readonly type: "string";
+                            readonly description: "CDN URL used when the dependency is resolved in CDN mode.";
+                        };
+                    };
+                }];
+                readonly description: "Resolution target of a dependency: either a plain string or an object with local, type and cdn options.";
+            };
+            readonly default: Record<string, never>;
+            readonly description: "Mapping of dependency names to their resolution targets (local file or CDN). Paths are resolved relative to this folder.";
+        };
+        readonly dependencies: {
+            readonly type: "array";
+            readonly default: never[];
+            readonly items: {
+                readonly type: "object";
+                readonly keys: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly required: true;
+                        readonly pattern: RegExp;
+                        readonly description: "Unique name used to reference the dependency in flows and path aliases. It is an identity, not a path: a single alphanumeric segment.";
+                    };
+                    readonly repo: {
+                        readonly type: "string";
+                        readonly required: true;
+                        readonly description: "Git repository URL to clone the dependency from.";
+                    };
+                    readonly tag: {
+                        readonly type: "string";
+                        readonly default: "main";
+                        readonly description: "Git tag, branch or commit to check out after cloning. Defaults to \"main\".";
+                    };
+                    readonly builder: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "union";
+                            readonly required: true;
+                            readonly union: readonly [{
+                                readonly type: "object";
+                                readonly required: true;
+                                readonly keys: {
+                                    readonly maxTimeMs: {
+                                        readonly type: "number";
+                                        readonly default: 60000;
+                                        readonly minimum: -1;
+                                        readonly description: "Maximum execution time for the run step in milliseconds. A value of -1 disables the limit.";
+                                    };
+                                    readonly allowFails: {
+                                        readonly type: "boolean";
+                                        readonly default: false;
+                                        readonly description: "Whether failed commands within the step are tolerated. Defaults to false.";
+                                    };
+                                    readonly run: {
+                                        readonly type: "union";
+                                        readonly required: true;
+                                        readonly union: readonly [{
+                                            readonly type: "string";
+                                        }, {
+                                            readonly type: "array";
+                                            readonly items: {
+                                                readonly type: "string";
+                                            };
+                                        }];
+                                        readonly description: "Shell command or list of shell commands to execute.";
+                                    };
+                                };
+                            }, {
+                                readonly type: "object";
+                                readonly required: true;
+                                readonly keys: {
+                                    readonly extract: {
+                                        readonly type: "union";
+                                        readonly required: true;
+                                        readonly union: readonly [{
+                                            readonly type: "string";
+                                        }, {
+                                            readonly type: "object";
+                                            readonly required: true;
+                                            readonly additional: {
+                                                readonly type: "union";
+                                                readonly required: true;
+                                                readonly union: readonly [{
+                                                    readonly type: "string";
+                                                    readonly required: true;
+                                                }, {
+                                                    readonly type: "object";
+                                                    readonly required: true;
+                                                    readonly keys: {
+                                                        readonly to: {
+                                                            readonly type: "string";
+                                                            readonly required: true;
+                                                            readonly description: "Destination folder to which the matched files are copied. A relative path is resolved against the project root, an absolute one is used as it stands.";
+                                                        };
+                                                        readonly map: {
+                                                            readonly type: "union";
+                                                            readonly union: readonly [{
+                                                                readonly type: "string";
+                                                            }, {
+                                                                readonly type: "object";
+                                                                readonly keys: {
+                                                                    readonly search: {
+                                                                        readonly type: "string";
+                                                                        readonly required: true;
+                                                                        readonly description: "The regular expression pattern to search for in the file content.";
+                                                                    };
+                                                                    readonly flags: {
+                                                                        readonly type: "string";
+                                                                        readonly default: "g";
+                                                                        readonly pattern: RegExp;
+                                                                        readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
+                                                                    };
+                                                                    readonly replace: {
+                                                                        readonly type: "string";
+                                                                        readonly required: true;
+                                                                        readonly description: "The replacement string used to substitute the matches found by the search pattern.";
+                                                                    };
+                                                                };
+                                                            }];
+                                                            readonly required: false;
+                                                            readonly description: "Transformation applied to the destination path of the extracted files.";
+                                                        };
+                                                        readonly transform: {
+                                                            readonly type: "union";
+                                                            readonly union: readonly [{
+                                                                readonly type: "string";
+                                                            }, {
+                                                                readonly type: "object";
+                                                                readonly keys: {
+                                                                    readonly search: {
+                                                                        readonly type: "string";
+                                                                        readonly required: true;
+                                                                        readonly description: "The regular expression pattern to search for in the file content.";
+                                                                    };
+                                                                    readonly flags: {
+                                                                        readonly type: "string";
+                                                                        readonly default: "g";
+                                                                        readonly pattern: RegExp;
+                                                                        readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
+                                                                    };
+                                                                    readonly replace: {
+                                                                        readonly type: "string";
+                                                                        readonly required: true;
+                                                                        readonly description: "The replacement string used to substitute the matches found by the search pattern.";
+                                                                    };
+                                                                };
+                                                            }];
+                                                            readonly required: false;
+                                                            readonly description: "Transformation applied to the content of the extracted files.";
+                                                        };
+                                                    };
+                                                }];
+                                            };
+                                            readonly description: "Mapping of source glob patterns, relative to the folder the pipeline works in, to extraction entries, each describing where and how files are extracted.";
+                                        }];
+                                        readonly description: "Destination folder for the extracted files or an extraction mapping.";
+                                    };
+                                };
+                            }, {
+                                readonly type: "object";
+                                readonly required: true;
+                                readonly keys: {
+                                    readonly transform: {
+                                        readonly type: "object";
+                                        readonly required: true;
+                                        readonly keys: {
+                                            readonly search: {
+                                                readonly type: "string";
+                                                readonly required: true;
+                                                readonly description: "The regular expression pattern to search for in the file content.";
+                                            };
+                                            readonly flags: {
+                                                readonly type: "string";
+                                                readonly default: "g";
+                                                readonly pattern: RegExp;
+                                                readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
+                                            };
+                                            readonly replace: {
+                                                readonly type: "string";
+                                                readonly required: true;
+                                                readonly description: "The replacement string used to substitute the matches found by the search pattern.";
+                                            };
+                                            readonly glob: {
+                                                readonly type: "string";
+                                                readonly required: true;
+                                                readonly description: "Glob pattern matching the files to which the global transformation is applied.";
+                                            };
+                                        };
+                                        readonly description: "Global transformation to apply over the files matched by the glob pattern.";
+                                    };
+                                };
+                            }];
+                            readonly description: "A single build step: run commands, extract files or apply a global transformation.";
+                        };
+                        readonly default: never[];
+                        readonly description: "Build pipeline applied after cloning the repository.";
+                    };
+                    readonly resolver: {
+                        readonly type: "object";
+                        readonly required: true;
+                        readonly additional: {
+                            readonly type: "union";
+                            readonly required: true;
+                            readonly union: readonly [{
+                                readonly type: "string";
+                            }, {
+                                readonly type: "object";
+                                readonly keys: {
+                                    readonly local: {
+                                        readonly type: "string";
+                                        readonly required: true;
+                                        readonly description: "Local path or glob pattern the dependency resolves to.";
+                                    };
+                                    readonly type: {
+                                        readonly type: "string";
+                                        readonly description: "Optional identifier describing the resolution type.";
+                                    };
+                                    readonly cdn: {
+                                        readonly type: "string";
+                                        readonly description: "CDN URL used when the dependency is resolved in CDN mode.";
+                                    };
+                                };
+                            }];
+                            readonly description: "Resolution target of a dependency: either a plain string or an object with local, type and cdn options.";
+                        };
+                        readonly default: Record<string, never>;
+                        readonly description: "Target resolution used to rewrite the dependency paths.";
+                    };
+                };
+            };
+            readonly description: "Git dependencies to clone and build, each an object with a name and a repo.";
+        };
+        readonly npmDependencies: {
+            readonly type: "array";
+            readonly default: never[];
+            readonly items: {
+                readonly type: "object";
+                readonly keys: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly required: true;
+                        readonly pattern: RegExp;
+                        readonly description: "NPM package name to install, optionally scoped.";
+                    };
+                    readonly version: {
+                        readonly type: "string";
+                        readonly required: true;
+                        readonly description: "NPM package version or semver range to install.";
+                    };
+                    readonly builder: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "union";
+                            readonly required: true;
+                            readonly union: readonly [{
+                                readonly type: "object";
+                                readonly required: true;
+                                readonly keys: {
+                                    readonly maxTimeMs: {
+                                        readonly type: "number";
+                                        readonly default: 60000;
+                                        readonly minimum: -1;
+                                        readonly description: "Maximum execution time for the run step in milliseconds. A value of -1 disables the limit.";
+                                    };
+                                    readonly allowFails: {
+                                        readonly type: "boolean";
+                                        readonly default: false;
+                                        readonly description: "Whether failed commands within the step are tolerated. Defaults to false.";
+                                    };
+                                    readonly run: {
+                                        readonly type: "union";
+                                        readonly required: true;
+                                        readonly union: readonly [{
+                                            readonly type: "string";
+                                        }, {
+                                            readonly type: "array";
+                                            readonly items: {
+                                                readonly type: "string";
+                                            };
+                                        }];
+                                        readonly description: "Shell command or list of shell commands to execute.";
+                                    };
+                                };
+                            }, {
+                                readonly type: "object";
+                                readonly required: true;
+                                readonly keys: {
+                                    readonly extract: {
+                                        readonly type: "union";
+                                        readonly required: true;
+                                        readonly union: readonly [{
+                                            readonly type: "string";
+                                        }, {
+                                            readonly type: "object";
+                                            readonly required: true;
+                                            readonly additional: {
+                                                readonly type: "union";
+                                                readonly required: true;
+                                                readonly union: readonly [{
+                                                    readonly type: "string";
+                                                    readonly required: true;
+                                                }, {
+                                                    readonly type: "object";
+                                                    readonly required: true;
+                                                    readonly keys: {
+                                                        readonly to: {
+                                                            readonly type: "string";
+                                                            readonly required: true;
+                                                            readonly description: "Destination folder to which the matched files are copied. A relative path is resolved against the project root, an absolute one is used as it stands.";
+                                                        };
+                                                        readonly map: {
+                                                            readonly type: "union";
+                                                            readonly union: readonly [{
+                                                                readonly type: "string";
+                                                            }, {
+                                                                readonly type: "object";
+                                                                readonly keys: {
+                                                                    readonly search: {
+                                                                        readonly type: "string";
+                                                                        readonly required: true;
+                                                                        readonly description: "The regular expression pattern to search for in the file content.";
+                                                                    };
+                                                                    readonly flags: {
+                                                                        readonly type: "string";
+                                                                        readonly default: "g";
+                                                                        readonly pattern: RegExp;
+                                                                        readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
+                                                                    };
+                                                                    readonly replace: {
+                                                                        readonly type: "string";
+                                                                        readonly required: true;
+                                                                        readonly description: "The replacement string used to substitute the matches found by the search pattern.";
+                                                                    };
+                                                                };
+                                                            }];
+                                                            readonly required: false;
+                                                            readonly description: "Transformation applied to the destination path of the extracted files.";
+                                                        };
+                                                        readonly transform: {
+                                                            readonly type: "union";
+                                                            readonly union: readonly [{
+                                                                readonly type: "string";
+                                                            }, {
+                                                                readonly type: "object";
+                                                                readonly keys: {
+                                                                    readonly search: {
+                                                                        readonly type: "string";
+                                                                        readonly required: true;
+                                                                        readonly description: "The regular expression pattern to search for in the file content.";
+                                                                    };
+                                                                    readonly flags: {
+                                                                        readonly type: "string";
+                                                                        readonly default: "g";
+                                                                        readonly pattern: RegExp;
+                                                                        readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
+                                                                    };
+                                                                    readonly replace: {
+                                                                        readonly type: "string";
+                                                                        readonly required: true;
+                                                                        readonly description: "The replacement string used to substitute the matches found by the search pattern.";
+                                                                    };
+                                                                };
+                                                            }];
+                                                            readonly required: false;
+                                                            readonly description: "Transformation applied to the content of the extracted files.";
+                                                        };
+                                                    };
+                                                }];
+                                            };
+                                            readonly description: "Mapping of source glob patterns, relative to the folder the pipeline works in, to extraction entries, each describing where and how files are extracted.";
+                                        }];
+                                        readonly description: "Destination folder for the extracted files or an extraction mapping.";
+                                    };
+                                };
+                            }, {
+                                readonly type: "object";
+                                readonly required: true;
+                                readonly keys: {
+                                    readonly transform: {
+                                        readonly type: "object";
+                                        readonly required: true;
+                                        readonly keys: {
+                                            readonly search: {
+                                                readonly type: "string";
+                                                readonly required: true;
+                                                readonly description: "The regular expression pattern to search for in the file content.";
+                                            };
+                                            readonly flags: {
+                                                readonly type: "string";
+                                                readonly default: "g";
+                                                readonly pattern: RegExp;
+                                                readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
+                                            };
+                                            readonly replace: {
+                                                readonly type: "string";
+                                                readonly required: true;
+                                                readonly description: "The replacement string used to substitute the matches found by the search pattern.";
+                                            };
+                                            readonly glob: {
+                                                readonly type: "string";
+                                                readonly required: true;
+                                                readonly description: "Glob pattern matching the files to which the global transformation is applied.";
+                                            };
+                                        };
+                                        readonly description: "Global transformation to apply over the files matched by the glob pattern.";
+                                    };
+                                };
+                            }];
+                            readonly description: "A single build step: run commands, extract files or apply a global transformation.";
+                        };
+                        readonly default: never[];
+                        readonly description: "Build pipeline applied after installing the package.";
+                    };
+                    readonly resolver: {
+                        readonly type: "object";
+                        readonly required: true;
+                        readonly additional: {
+                            readonly type: "union";
+                            readonly required: true;
+                            readonly union: readonly [{
+                                readonly type: "string";
+                            }, {
+                                readonly type: "object";
+                                readonly keys: {
+                                    readonly local: {
+                                        readonly type: "string";
+                                        readonly required: true;
+                                        readonly description: "Local path or glob pattern the dependency resolves to.";
+                                    };
+                                    readonly type: {
+                                        readonly type: "string";
+                                        readonly description: "Optional identifier describing the resolution type.";
+                                    };
+                                    readonly cdn: {
+                                        readonly type: "string";
+                                        readonly description: "CDN URL used when the dependency is resolved in CDN mode.";
+                                    };
+                                };
+                            }];
+                            readonly description: "Resolution target of a dependency: either a plain string or an object with local, type and cdn options.";
+                        };
+                        readonly default: Record<string, never>;
+                        readonly description: "Target resolution used to rewrite the dependency paths.";
+                    };
+                };
+            };
+            readonly description: "NPM dependencies to install and build, each an object with a name and a version.";
+        };
+    };
+}>;
+export type Config = typeof Config.infer;
+export declare namespace Config { }
+export default Config;