@utilarium/dreadcabinet 0.0.16-dev.0

package/dist/dreadcabinet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dreadcabinet.js","sources":["../src/dreadcabinet.ts"],"sourcesContent":["import { Command } from 'commander';\nimport { configure } from './configure';\nimport { applyDefaults } from './defaults';\nimport { read } from './read';\nimport { validate } from './validate';\n\nimport { ALLOWED_EXTENSIONS, ALLOWED_INPUT_FILENAME_OPTIONS, ALLOWED_INPUT_STRUCTURES, ALLOWED_OUTPUT_FILENAME_OPTIONS, ALLOWED_OUTPUT_STRUCTURES, DEFAULT_CONCURRENCY, DEFAULT_EXTENSIONS, DEFAULT_INPUT_DIRECTORY, DEFAULT_INPUT_FILENAME_OPTIONS, DEFAULT_INPUT_STRUCTURE, DEFAULT_OUTPUT_DIRECTORY, DEFAULT_OUTPUT_FILENAME_OPTIONS, DEFAULT_OUTPUT_STRUCTURE, DEFAULT_RECURSIVE, DEFAULT_TIMEZONE } from './constants';\nimport { z } from 'zod';\nimport { create as createOperator } from './operate';\nimport { wrapLogger } from './logger';\n\nexport interface Args {\n    recursive: boolean;\n    timezone: string;\n    inputDirectory: string;\n    inputStructure?: FilesystemStructure;\n    inputFilenameOptions?: FilenameOption[];\n    outputDirectory: string;\n    outputStructure?: FilesystemStructure;\n    outputFilenameOptions?: FilenameOption[];\n    extensions: string[];\n    start?: string; // Start date string\n    end?: string;   // End date string\n    limit?: number; // Limit the number of files to process\n    concurrency?: number; // Concurrency level for processing files\n}\n\nexport type Feature = 'input' | 'output' | 'structured-output' | 'structured-input' | 'extensions';\n\nexport const FilenameOptionSchema = z.enum([\n    'date',\n    'time',\n    'subject',\n]);\n\nexport type FilenameOption = z.infer<typeof FilenameOptionSchema>;\n\nexport const FilesystemStructureSchema = z.enum([\n    'none',\n    'year',\n    'month',\n    'day',\n]);\n\nexport type FilesystemStructure = z.infer<typeof FilesystemStructureSchema>;\n\nexport interface DefaultOptions {\n    timezone?: string;\n    recursive?: boolean;\n    inputDirectory?: string;\n    inputStructure?: FilesystemStructure;\n    inputFilenameOptions?: FilenameOption[];\n    outputDirectory?: string;\n    outputStructure?: FilesystemStructure;\n    outputFilenameOptions?: FilenameOption[];\n    extensions?: string[];\n    startDate?: string;\n    endDate?: string;\n    limit?: number;\n    concurrency?: number;\n}\n\nexport interface AllowedOptions {\n    inputStructures?: FilesystemStructure[];\n    inputFilenameOptions?: FilenameOption[];\n    outputStructures?: FilesystemStructure[];\n    outputFilenameOptions?: FilenameOption[];\n    extensions?: string[];\n}\n\nexport interface Options {\n    defaults?: DefaultOptions,\n    allowed?: AllowedOptions,\n    features: Feature[],\n    addDefaults: boolean;\n    logger: Logger;\n}\n\nexport interface Logger {\n    debug: (message: string, ...args: any[]) => void;\n    info: (message: string, ...args: any[]) => void;\n    warn: (message: string, ...args: any[]) => void;\n    error: (message: string, ...args: any[]) => void;\n    verbose: (message: string, ...args: any[]) => void;\n    silly: (message: string, ...args: any[]) => void;\n}\n\nexport const DEFAULT_APP_OPTIONS: DefaultOptions = {\n    timezone: DEFAULT_TIMEZONE,\n    recursive: DEFAULT_RECURSIVE,\n    inputDirectory: DEFAULT_INPUT_DIRECTORY,\n    inputStructure: DEFAULT_INPUT_STRUCTURE,\n    inputFilenameOptions: DEFAULT_INPUT_FILENAME_OPTIONS,\n    outputDirectory: DEFAULT_OUTPUT_DIRECTORY,\n    outputStructure: DEFAULT_OUTPUT_STRUCTURE,\n    outputFilenameOptions: DEFAULT_OUTPUT_FILENAME_OPTIONS,\n    extensions: DEFAULT_EXTENSIONS,\n    concurrency: DEFAULT_CONCURRENCY,\n}\n\nexport const DEFAULT_ALLOWED_OPTIONS: AllowedOptions = {\n    inputStructures: ALLOWED_INPUT_STRUCTURES,\n    inputFilenameOptions: ALLOWED_INPUT_FILENAME_OPTIONS,\n    outputStructures: ALLOWED_OUTPUT_STRUCTURES,\n    outputFilenameOptions: ALLOWED_OUTPUT_FILENAME_OPTIONS,\n    extensions: ALLOWED_EXTENSIONS,\n}\n\nexport const DEFAULT_FEATURES: Feature[] = ['output', 'structured-output', 'input', 'extensions'];\n\nexport const DEFAULT_LOGGER: Logger = {\n    // eslint-disable-next-line no-console\n    debug: (message: string, ...args: any[]) => console.debug(message, ...args),\n    // eslint-disable-next-line no-console\n    info: (message: string, ...args: any[]) => console.info(message, ...args),\n    // eslint-disable-next-line no-console\n    warn: (message: string, ...args: any[]) => console.warn(message, ...args),\n    // eslint-disable-next-line no-console\n    error: (message: string, ...args: any[]) => console.error(message, ...args),\n    // eslint-disable-next-line no-console\n    verbose: (message: string, ...args: any[]) => console.log(message, ...args),\n    // eslint-disable-next-line no-console\n    silly: (message: string, ...args: any[]) => console.log(message, ...args),\n}\n\nexport const DEFAULT_OPTIONS = {\n    defaults: DEFAULT_APP_OPTIONS,\n    allowed: DEFAULT_ALLOWED_OPTIONS,\n    features: DEFAULT_FEATURES,\n    addDefaults: true,\n    logger: DEFAULT_LOGGER,\n};\n\nexport const ConfigSchema = z.object({\n    timezone: z.string(),\n    inputDirectory: z.string().optional(),\n    inputStructure: FilesystemStructureSchema.optional(),\n    inputFilenameOptions: z.array(FilenameOptionSchema).optional(),\n    recursive: z.boolean().optional(),\n    outputDirectory: z.string().optional(),\n    outputStructure: FilesystemStructureSchema.optional(),\n    outputFilenameOptions: z.array(FilenameOptionSchema).optional(),\n    extensions: z.array(z.string()).optional(),\n    limit: z.number().optional(),\n    concurrency: z.number().optional(),\n});\n\nexport interface DateRange {\n    start: Date;\n    end: Date;\n}\n\nexport type Config = z.infer<typeof ConfigSchema>;\n\nexport interface Operator {\n    process: (callback: (file: string) => Promise<void>, dateRange?: Partial<DateRange>, concurrency?: number) => Promise<void>;\n    constructFilename: (createDate: Date, type: string, hash: string, options?: { subject?: string }) => Promise<string>;\n    constructOutputDirectory: (createDate: Date) => Promise<string>;\n}\n\nexport interface DreadCabinet {\n    configure: (command: Command) => Promise<void>;\n    setLogger: (logger: Logger) => void;\n    read: (args: Args) => Promise<Partial<Config>>;\n    applyDefaults: (config: Partial<Config>) => Config;\n    validate: (config: Config) => Promise<void>;\n    operate: (config: Config) => Promise<Operator>;\n}\n\nexport const create = (\n    creationOptsParam: Partial<Options> = {}\n): DreadCabinet => {\n\n    let args: Args;\n\n    const options: Options = {\n        defaults: { ...DEFAULT_APP_OPTIONS, ...creationOptsParam.defaults },\n        allowed: { ...DEFAULT_ALLOWED_OPTIONS, ...creationOptsParam.allowed },\n        features: creationOptsParam.features || DEFAULT_FEATURES,\n        addDefaults: creationOptsParam.addDefaults === undefined ? DEFAULT_OPTIONS.addDefaults : creationOptsParam.addDefaults,\n        logger: wrapLogger(creationOptsParam.logger || DEFAULT_OPTIONS.logger)\n    };\n\n    return {\n        configure: async (command: Command) => configure(command, options.defaults || {}, options.addDefaults, options.features),\n        setLogger: (logger: Logger) => {\n            options.logger = wrapLogger(logger);\n        },\n        read: async (pArgs: Args) => {\n            args = pArgs;\n            return read(args, options.features);\n        },\n        applyDefaults: (config: Partial<Config>) => applyDefaults(config, options.features, options.defaults || {}),\n        validate: async (config: Config) => validate(config, options),\n        operate: async (config: Config) => createOperator(config, args, options),\n    }\n}\n\n\n\n\n\n"],"names":["FilenameOptionSchema","z","enum","FilesystemStructureSchema","DEFAULT_APP_OPTIONS","timezone","DEFAULT_TIMEZONE","recursive","DEFAULT_RECURSIVE","inputDirectory","DEFAULT_INPUT_DIRECTORY","inputStructure","DEFAULT_INPUT_STRUCTURE","inputFilenameOptions","DEFAULT_INPUT_FILENAME_OPTIONS","outputDirectory","DEFAULT_OUTPUT_DIRECTORY","outputStructure","DEFAULT_OUTPUT_STRUCTURE","outputFilenameOptions","DEFAULT_OUTPUT_FILENAME_OPTIONS","extensions","DEFAULT_EXTENSIONS","concurrency","DEFAULT_CONCURRENCY","DEFAULT_ALLOWED_OPTIONS","inputStructures","ALLOWED_INPUT_STRUCTURES","ALLOWED_INPUT_FILENAME_OPTIONS","outputStructures","ALLOWED_OUTPUT_STRUCTURES","ALLOWED_OUTPUT_FILENAME_OPTIONS","ALLOWED_EXTENSIONS","DEFAULT_FEATURES","DEFAULT_LOGGER","debug","message","args","console","info","warn","error","verbose","log","silly","DEFAULT_OPTIONS","defaults","allowed","features","addDefaults","logger","ConfigSchema","object","string","optional","array","boolean","limit","number","create","creationOptsParam","options","undefined","wrapLogger","configure","command","setLogger","read","pArgs","applyDefaults","config","validate","operate","createOperator"],"mappings":"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"}

package/dist/error/ArgumentError.d.ts

@@ -0,0 +1,5 @@
+export declare class ArgumentError extends Error {
+    private argumentName;
+    constructor(argumentName: string, message: string);
+    get argument(): string;
+}

package/dist/error/ArgumentError.js

@@ -0,0 +1,26 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class ArgumentError extends Error {
+    get argument() {
+        return this.argumentName;
+    }
+    constructor(argumentName, message){
+        super(`${message}`), _define_property(this, "argumentName", void 0);
+        this.name = 'ArgumentError';
+        this.argumentName = argumentName;
+    }
+}
+
+export { ArgumentError };
+//# sourceMappingURL=ArgumentError.js.map

package/dist/error/ArgumentError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArgumentError.js","sources":["../../src/error/ArgumentError.ts"],"sourcesContent":["export class ArgumentError extends Error {\n    private argumentName: string;\n    constructor(argumentName: string, message: string) {\n        super(`${message}`);\n        this.name = 'ArgumentError';\n        this.argumentName = argumentName;\n    }\n\n    get argument(): string {\n        return this.argumentName;\n    }\n}"],"names":["ArgumentError","Error","argument","argumentName","message","name"],"mappings":";;;;;;;;;;;;;AAAO,MAAMA,aAAAA,SAAsBC,KAAAA,CAAAA;AAQ/B,IAAA,IAAIC,QAAAA,GAAmB;QACnB,OAAO,IAAI,CAACC,YAAY;AAC5B,IAAA;IARA,WAAA,CAAYA,YAAoB,EAAEC,OAAe,CAAE;AAC/C,QAAA,KAAK,CAAC,CAAA,EAAGA,OAAAA,CAAAA,CAAS,CAAA,EAFtB,gBAAA,CAAA,IAAA,EAAQD,gBAAR,MAAA,CAAA;QAGI,IAAI,CAACE,IAAI,GAAG,eAAA;QACZ,IAAI,CAACF,YAAY,GAAGA,YAAAA;AACxB,IAAA;AAKJ;;;;"}

package/dist/input/input.d.ts

@@ -0,0 +1,7 @@
+import { Config, Options } from '../dreadcabinet';
+export declare const create: (config: Config, options: Options) => {
+    process: (callback: (file: string, date?: Date) => Promise<void>, { start, end }?: {
+        start?: Date;
+        end?: Date;
+    }) => Promise<void>;
+};

package/dist/input/input.js

@@ -0,0 +1,13 @@
+import { process } from './process.js';
+
+const create = (config, options)=>{
+    return {
+        process: (callback, { start, end } = {})=>process(config, options.features, options.logger, callback, {
+                start,
+                end
+            })
+    };
+};
+
+export { create };
+//# sourceMappingURL=input.js.map

package/dist/input/input.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.js","sources":["../../src/input/input.ts"],"sourcesContent":["import { Config, Options } from \"dreadcabinet\";\nimport { process } from './process';\n\nexport const create = (config: Config, options: Options) => {\n    type ProcessCallback = (file: string, date?: Date) => Promise<void>;\n\n    return {\n        process: (callback: ProcessCallback, { start, end }: { start?: Date, end?: Date } = {}) => process(config, options.features, options.logger, callback, { start, end }),\n    };\n}"],"names":["create","config","options","process","callback","start","end","features","logger"],"mappings":";;AAGO,MAAMA,MAAAA,GAAS,CAACC,MAAAA,EAAgBC,OAAAA,GAAAA;IAGnC,OAAO;AACHC,QAAAA,OAAAA,EAAS,CAACC,QAAAA,EAA2B,EAAEC,KAAK,EAAEC,GAAG,EAAgC,GAAG,EAAE,GAAKH,OAAAA,CAAQF,QAAQC,OAAAA,CAAQK,QAAQ,EAAEL,OAAAA,CAAQM,MAAM,EAAEJ,QAAAA,EAAU;AAAEC,gBAAAA,KAAAA;AAAOC,gBAAAA;AAAI,aAAA;AACxK,KAAA;AACJ;;;;"}

package/dist/input/process.d.ts

@@ -0,0 +1,5 @@
+import { Config, Feature, Logger } from '../dreadcabinet';
+export declare const process: (config: Config, features: Feature[], logger: Logger, callback: (file: string) => Promise<void>, { start, end }?: {
+    start?: Date;
+    end?: Date;
+}) => Promise<void>;

package/dist/input/process.js

@@ -0,0 +1,36 @@
+import { process as process$1 } from './structured.js';
+import { process as process$2 } from './unstructured.js';
+
+const process = async (config, features, logger, callback, { start, end } = {})=>{
+    if (!features.includes('input')) {
+        throw new Error('Input feature is not enabled, skipping input processing');
+    }
+    const concurrency = config.concurrency;
+    if (!concurrency) {
+        throw new Error('Concurrency is not configured');
+    }
+    const inputDirectory = config.inputDirectory;
+    if (!inputDirectory) {
+        throw new Error('Input directory is not configured');
+    }
+    let fileCount = 0;
+    if (features.includes('structured-input')) {
+        logger.debug('Processing Structured Input from %s with start date %s and end date %s', inputDirectory, start, end);
+        if (!start || !end) {
+            throw new Error('Start or end date are both required for structured input');
+        } else {
+            fileCount = await process$1(config.inputStructure, config.inputFilenameOptions, config.extensions, config.timezone, start, end, config.limit, features, logger, inputDirectory, callback, concurrency);
+        }
+    } else {
+        // Original Unstructured Input Logic
+        logger.debug('Processing Unstructured Input from %s', inputDirectory);
+        if (start || end) {
+            throw new Error('Start or end date is not allowed for unstructured input');
+        }
+        fileCount = await process$2(inputDirectory, config.recursive || false, config.extensions || [], config.limit, logger, callback, concurrency);
+    }
+    logger.info('Processed %d files matching criteria.', fileCount);
+};
+
+export { process };
+//# sourceMappingURL=process.js.map

package/dist/input/process.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"process.js","sources":["../../src/input/process.ts"],"sourcesContent":["import { Config, Feature, Logger } from \"dreadcabinet\";\nimport { process as processStructuredInput } from \"./structured\";\nimport { process as processUnstructuredInput } from \"./unstructured\";\n\nexport const process = async (\n    config: Config,\n    features: Feature[],\n    logger: Logger,\n    callback: (file: string) => Promise<void>,\n    { start, end }: { start?: Date, end?: Date } = {}\n) => {\n    if (!features.includes('input')) {\n        throw new Error('Input feature is not enabled, skipping input processing');\n    }\n\n    const concurrency = config.concurrency;\n    if (!concurrency) {\n        throw new Error('Concurrency is not configured');\n    }\n\n    const inputDirectory = config.inputDirectory;\n    if (!inputDirectory) {\n        throw new Error('Input directory is not configured');\n    }\n\n    let fileCount = 0;\n\n    if (features.includes('structured-input')) {\n        logger.debug('Processing Structured Input from %s with start date %s and end date %s', inputDirectory, start, end);\n\n        if (!start || !end) {\n            throw new Error('Start or end date are both required for structured input');\n        } else {\n            fileCount = await processStructuredInput(\n                config.inputStructure!,\n                config.inputFilenameOptions!,\n                config.extensions!,\n                config.timezone,\n                start,\n                end,\n                config.limit,\n                features,\n                logger,\n                inputDirectory,\n                callback,\n                concurrency\n            )\n        }\n\n\n    } else {\n        // Original Unstructured Input Logic\n        logger.debug('Processing Unstructured Input from %s', inputDirectory);\n\n        if (start || end) {\n            throw new Error('Start or end date is not allowed for unstructured input');\n        }\n\n        fileCount = await processUnstructuredInput(\n            inputDirectory,\n            config.recursive || false,\n            config.extensions || [],\n            config.limit,\n            logger,\n            callback,\n            concurrency\n        );\n    }\n\n    logger.info('Processed %d files matching criteria.', fileCount);\n};\n"],"names":["process","config","features","logger","callback","start","end","includes","Error","concurrency","inputDirectory","fileCount","debug","processStructuredInput","inputStructure","inputFilenameOptions","extensions","timezone","limit","processUnstructuredInput","recursive","info"],"mappings":";;;AAIO,MAAMA,OAAAA,GAAU,OACnBC,MAAAA,EACAC,UACAC,MAAAA,EACAC,QAAAA,EACA,EAAEC,KAAK,EAAEC,GAAG,EAAgC,GAAG,EAAE,GAAA;AAEjD,IAAA,IAAI,CAACJ,QAAAA,CAASK,QAAQ,CAAC,OAAA,CAAA,EAAU;AAC7B,QAAA,MAAM,IAAIC,KAAAA,CAAM,yDAAA,CAAA;AACpB,IAAA;IAEA,MAAMC,WAAAA,GAAcR,OAAOQ,WAAW;AACtC,IAAA,IAAI,CAACA,WAAAA,EAAa;AACd,QAAA,MAAM,IAAID,KAAAA,CAAM,+BAAA,CAAA;AACpB,IAAA;IAEA,MAAME,cAAAA,GAAiBT,OAAOS,cAAc;AAC5C,IAAA,IAAI,CAACA,cAAAA,EAAgB;AACjB,QAAA,MAAM,IAAIF,KAAAA,CAAM,mCAAA,CAAA;AACpB,IAAA;AAEA,IAAA,IAAIG,SAAAA,GAAY,CAAA;IAEhB,IAAIT,QAAAA,CAASK,QAAQ,CAAC,kBAAA,CAAA,EAAqB;AACvCJ,QAAAA,MAAAA,CAAOS,KAAK,CAAC,wEAAA,EAA0EF,cAAAA,EAAgBL,KAAAA,EAAOC,GAAAA,CAAAA;QAE9G,IAAI,CAACD,KAAAA,IAAS,CAACC,GAAAA,EAAK;AAChB,YAAA,MAAM,IAAIE,KAAAA,CAAM,0DAAA,CAAA;QACpB,CAAA,MAAO;YACHG,SAAAA,GAAY,MAAME,UACdZ,MAAAA,CAAOa,cAAc,EACrBb,MAAAA,CAAOc,oBAAoB,EAC3Bd,MAAAA,CAAOe,UAAU,EACjBf,OAAOgB,QAAQ,EACfZ,OACAC,GAAAA,EACAL,MAAAA,CAAOiB,KAAK,EACZhB,QAAAA,EACAC,MAAAA,EACAO,cAAAA,EACAN,QAAAA,EACAK,WAAAA,CAAAA;AAER,QAAA;IAGJ,CAAA,MAAO;;QAEHN,MAAAA,CAAOS,KAAK,CAAC,uCAAA,EAAyCF,cAAAA,CAAAA;AAEtD,QAAA,IAAIL,SAASC,GAAAA,EAAK;AACd,YAAA,MAAM,IAAIE,KAAAA,CAAM,yDAAA,CAAA;AACpB,QAAA;AAEAG,QAAAA,SAAAA,GAAY,MAAMQ,SAAAA,CACdT,cAAAA,EACAT,MAAAA,CAAOmB,SAAS,IAAI,KAAA,EACpBnB,MAAAA,CAAOe,UAAU,IAAI,EAAE,EACvBf,MAAAA,CAAOiB,KAAK,EACZf,QACAC,QAAAA,EACAK,WAAAA,CAAAA;AAER,IAAA;IAEAN,MAAAA,CAAOkB,IAAI,CAAC,uCAAA,EAAyCV,SAAAA,CAAAA;AACzD;;;;"}

package/dist/input/structured.d.ts

@@ -0,0 +1,15 @@
+import { Feature, FilenameOption, FilesystemStructure, Logger } from '../dreadcabinet';
+import { z } from 'zod';
+export declare const DateRangeSchema: z.ZodObject<{
+    start: z.ZodDate;
+    end: z.ZodDate;
+}, z.core.$strip>;
+export type DateRange = z.infer<typeof DateRangeSchema>;
+export declare const getFilePattern: (features: Feature[], extensions: string[], logger: Logger) => string;
+export declare const parseDateFromString: (dateStr: string, format: "YYYY-M-D-HHmm" | "M-D-HHmm" | "D-HHmm" | "HHmm", shouldParseTime: boolean, // New required parameter
+year?: number, month?: number, day?: number) => Date | null;
+export declare const isDateInRange: (date: Date, range?: DateRange) => boolean;
+export declare const calculateDateRange: (timezone: string, startDate: Date, endDate: Date) => DateRange;
+export declare const parseDateFromFilePath: (relativePath: string, filename: string, structure: string, shouldParseTime: boolean, logger: Logger) => Date | null;
+export declare const processStructuredFile: (filePath: string, inputDirectory: string, structure: string, shouldParseTime: boolean, callback: (file: string, date?: Date) => Promise<void>, pattern: string, dateRange: DateRange, logger: Logger) => Promise<boolean>;
+export declare const process: (inputStructure: FilesystemStructure, inputFilenameOptions: FilenameOption[], extensions: string[], timezone: string, start: Date, end: Date, limit: number | undefined, features: Feature[], logger: Logger, inputDirectory: string, callback: (file: string, date?: Date) => Promise<void>, concurrency?: number) => Promise<number>;

package/dist/input/structured.js

@@ -0,0 +1,324 @@
+import * as path from 'node:path';
+import { z } from 'zod';
+import { DATE_FORMAT_YEAR_MONTH_DAY } from '../constants.js';
+import { ArgumentError } from '../error/ArgumentError.js';
+import { create as create$1 } from '../util/dates.js';
+import { create } from '../util/storage.js';
+
+z.object({
+    start: z.date(),
+    end: z.date()
+});
+// Get the appropriate file pattern based on config and options
+const getFilePattern = (features, extensions, logger)=>{
+    // Validate extensions: they should not start with a dot.
+    if (extensions && extensions.length > 0) {
+        for (const ext of extensions){
+            if (ext.startsWith('.')) {
+                // Throw an error as the dot is added automatically by the pattern generation.
+                // Using ArgumentError might be more consistent if available and appropriate here.
+                throw new Error(`Invalid extension format: "${ext}". Extensions should not start with a dot ('.').`);
+            }
+        }
+    }
+    let pattern = '**/*'; // Start with a broad pattern for recursive search
+    if (features.includes('extensions') && extensions && extensions.length > 0) {
+        if (extensions.length === 1) {
+            pattern = `**/*.${extensions[0]}`;
+        } else {
+            pattern = `**/*.{${extensions.join(',')}}`;
+        }
+        logger.debug(`Applying extension filter: ${extensions.join(',')}`);
+    } else {
+        pattern = `**/*.*`;
+        logger.debug(`No extension filter applied, using pattern: ${pattern}`);
+    }
+    return pattern;
+};
+// Helper function to parse date string based on expected format
+// Returns null if parsing fails
+const parseDateFromString = (dateStr, format, shouldParseTime, year, month, day)=>{
+    // Basic validation
+    if (!dateStr) return null;
+    try {
+        let y = year !== null && year !== void 0 ? year : 0;
+        let mo = month !== null && month !== void 0 ? month : 0; // JS months are 0-indexed
+        let d = day !== null && day !== void 0 ? day : 1; // JS days are 1-indexed
+        let h = 0; // Default to 0
+        let mi = 0; // Default to 0
+        // Remove potential leading/trailing non-alphanumeric if needed, split by common separators
+        const cleanedDateStr = dateStr.replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, '');
+        const parts = cleanedDateStr.split(/[-_]/); // Allow dash or underscore
+        switch(format){
+            case 'YYYY-M-D-HHmm':
+                {
+                    if (parts.length < 4 && shouldParseTime) return null; // Need time part if parsing it
+                    if (parts.length < 3 && !shouldParseTime) return null; // Need at least date part
+                    y = parseInt(parts[0], 10);
+                    mo = parseInt(parts[1], 10) - 1; // Adjust month
+                    d = parseInt(parts[2], 10);
+                    if (shouldParseTime) {
+                        const timePartYD = parts[3];
+                        if (timePartYD.length < 4) return null; // Ensure HHmm exists
+                        h = parseInt(timePartYD.substring(0, 2), 10);
+                        mi = parseInt(timePartYD.substring(2, 4), 10);
+                    }
+                    break;
+                }
+            case 'M-D-HHmm':
+                {
+                    if (year === undefined) return null;
+                    if (parts.length < 3 && shouldParseTime) return null;
+                    if (parts.length < 2 && !shouldParseTime) return null;
+                    mo = parseInt(parts[0], 10) - 1; // Adjust month
+                    d = parseInt(parts[1], 10);
+                    if (shouldParseTime) {
+                        const timePartMD = parts[2];
+                        if (timePartMD.length < 4) return null; // Ensure HHmm exists
+                        h = parseInt(timePartMD.substring(0, 2), 10);
+                        mi = parseInt(timePartMD.substring(2, 4), 10);
+                    }
+                    break;
+                }
+            case 'D-HHmm':
+                {
+                    if (year === undefined || month === undefined) return null;
+                    if (parts.length < 2 && shouldParseTime) return null;
+                    if (parts.length < 1 && !shouldParseTime) return null;
+                    d = parseInt(parts[0], 10);
+                    if (shouldParseTime) {
+                        const timePartD = parts[1];
+                        if (timePartD.length < 4) return null; // Ensure HHmm exists
+                        h = parseInt(timePartD.substring(0, 2), 10);
+                        mi = parseInt(timePartD.substring(2, 4), 10);
+                    }
+                    break;
+                }
+            case 'HHmm':
+                if (year === undefined || month === undefined || day === undefined) return null;
+                if (shouldParseTime) {
+                    if (parts[0].length !== 4) return null;
+                    h = parseInt(parts[0].substring(0, 2), 10);
+                    mi = parseInt(parts[0].substring(2, 4), 10);
+                } // Else h=0, mi=0 (set by defaults)
+                break;
+            default:
+                return null;
+        }
+        // Validate parsed numbers
+        if (isNaN(y) || isNaN(mo) || isNaN(d)) {
+            throw new Error(`Invalid date components in date string "${dateStr}" with format ${format}: Y:${y} M:${mo} D:${d}`);
+        }
+        // Set hour and minute to 0 if not provided
+        if (isNaN(h)) {
+            h = 0;
+        }
+        if (isNaN(mi)) {
+            mi = 0;
+        }
+        if (mo < 0 || mo > 11 || d < 1 || d > 31 || h < 0 || h > 23 || mi < 0 || mi > 59) {
+            throw new Error(`Invalid date components in date string "${dateStr}" with format ${format}: Y:${y} M:${mo + 1} D:${d} H:${h} m:${mi}`);
+        }
+        const date = new Date(Date.UTC(y, mo, d, h, mi));
+        // Double check components as Date object might adjust invalid dates (e.g. Feb 30th -> Mar 2nd)
+        if (date.getUTCFullYear() !== y || date.getUTCMonth() !== mo || date.getUTCDate() !== d || date.getUTCHours() !== h || date.getUTCMinutes() !== mi) {
+            // console.debug(`Date validation failed for Y:${y} M:${mo} D:${d} H:${h} m:${mi}. JS Date adjusted it.`);
+            return null;
+        }
+        return date;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (e) {
+        // console.error(`Error parsing date string "${dateStr}" with format ${format}:`, e);
+        return null;
+    }
+};
+// Helper to check if date is within range (start inclusive, end exclusive)
+const isDateInRange = (date, range)=>{
+    if (!range || !range.start && !range.end) return true; // No range or empty range means all dates are valid
+    // Ensure range dates are Date objects
+    const startDate = range.start ? range.start instanceof Date ? range.start : new Date(range.start) : null;
+    const endDate = range.end ? range.end instanceof Date ? range.end : new Date(range.end) : null;
+    // Validate parsed range dates
+    const isStartDateValid = startDate && !isNaN(startDate.getTime());
+    const isEndDateValid = endDate && !isNaN(endDate.getTime());
+    if (isStartDateValid && date < startDate) {
+        return false;
+    }
+    // End date is exclusive
+    if (isEndDateValid && date >= endDate) {
+        return false;
+    }
+    return true;
+};
+const calculateDateRange = (timezone, startDate, endDate)=>{
+    // Create date utility after timezone is validated
+    const dateUtil = create$1({
+        timezone
+    });
+    const now = dateUtil.now();
+    const range = {
+        start: dateUtil.subDays(now, 31),
+        end: now
+    };
+    // Note: Validation ensures dates are valid and start <= end if both are provided
+    if (startDate || endDate) {
+        // Handle end date
+        if (endDate) {
+            range.end = dateUtil.parse(endDate, DATE_FORMAT_YEAR_MONTH_DAY);
+        }
+        // Handle start date
+        if (startDate) {
+            range.start = dateUtil.parse(startDate, DATE_FORMAT_YEAR_MONTH_DAY);
+        }
+        // We re-check the order here after defaults might have been applied,
+        // although validateStartEndDates should catch explicit invalid orders.
+        if (dateUtil.isBefore(range.end, range.start)) {
+            // This case should theoretically not be reachable due to prior validation
+            // but is kept as a safeguard.
+            throw new ArgumentError('--start', `Start date (${dateUtil.format(range.start, DATE_FORMAT_YEAR_MONTH_DAY)}) cannot be after end date (${dateUtil.format(range.end, DATE_FORMAT_YEAR_MONTH_DAY)}).`);
+        }
+    }
+    return range;
+};
+// Parse date from file path based on the input structure
+const parseDateFromFilePath = (relativePath, filename, structure, shouldParseTime, logger)=>{
+    const pathParts = relativePath.split(path.sep);
+    const filenameWithoutExt = path.basename(filename, path.extname(filename));
+    let parsedDate = null;
+    let year;
+    let month; // 0-indexed month for Date constructor
+    let day;
+    switch(structure){
+        case 'none':
+            // Filename format: YYYY-M-D-HHmm...
+            parsedDate = parseDateFromString(filenameWithoutExt, 'YYYY-M-D-HHmm', shouldParseTime);
+            break;
+        case 'year':
+            // Path: YYYY / M-D-HHmm...
+            if (pathParts.length >= 1) {
+                year = parseInt(pathParts[0], 10);
+                if (!isNaN(year)) {
+                    parsedDate = parseDateFromString(filenameWithoutExt, 'M-D-HHmm', shouldParseTime, year);
+                } else {
+                    logger.warn(`Invalid year format in path: ${pathParts[0]}`);
+                }
+            } else {
+                logger.warn(`File path does not match expected 'year' structure (YYYY/...)`);
+            }
+            break;
+        case 'month':
+            // Path: YYYY / MM / D-HHmm...
+            if (pathParts.length >= 2) {
+                year = parseInt(pathParts[0], 10);
+                const monthDir = parseInt(pathParts[1], 10); // Month from dir (1-indexed)
+                if (!isNaN(year) && !isNaN(monthDir) && monthDir >= 1 && monthDir <= 12) {
+                    month = monthDir - 1; // Adjust month for Date object (0-indexed)
+                    parsedDate = parseDateFromString(filenameWithoutExt, 'D-HHmm', shouldParseTime, year, month);
+                } else {
+                    logger.warn(`Invalid year/month format in path: ${pathParts[0]}/${pathParts[1]}`);
+                }
+            } else {
+                logger.warn(`File path does not match expected 'month' structure (YYYY/MM/...)`);
+            }
+            break;
+        case 'day':
+            // Path: YYYY / MM / DD / HHmm...
+            if (pathParts.length >= 3) {
+                year = parseInt(pathParts[0], 10);
+                const monthDir = parseInt(pathParts[1], 10); // Month from dir (1-indexed)
+                day = parseInt(pathParts[2], 10); // Day from dir (1-indexed)
+                if (!isNaN(year) && !isNaN(monthDir) && monthDir >= 1 && monthDir <= 12 && !isNaN(day) && day >= 1 && day <= 31) {
+                    month = monthDir - 1; // Adjust month (0-indexed)
+                    parsedDate = parseDateFromString(filenameWithoutExt, 'HHmm', shouldParseTime, year, month, day);
+                } else {
+                    logger.warn(`Invalid year/month/day format in path: ${pathParts[0]}/${pathParts[1]}/${pathParts[2]}`);
+                }
+            } else {
+                logger.warn(`File path does not match expected 'day' structure (YYYY/MM/DD/...)`);
+            }
+            break;
+        default:
+            logger.error(`Fatal: Unknown input structure "${structure}" specified in config.`);
+            throw new Error(`Unknown input structure "${structure}" specified.`);
+    }
+    return parsedDate;
+};
+// Process a single file from the structured input
+const processStructuredFile = async (filePath, inputDirectory, structure, shouldParseTime, callback, pattern, dateRange, logger)=>{
+    // Skip if filePath somehow points to the inputDirectory itself or is not a file
+    if (filePath === inputDirectory || !path.extname(filePath) && pattern.endsWith('*.*')) {
+        return false;
+    }
+    const relativePath = path.relative(inputDirectory, filePath);
+    const pathParts = relativePath.split(path.sep);
+    const filename = pathParts.pop(); // Filename is the last part
+    if (!filename) {
+        logger.warn(`Could not determine filename for path: ${filePath}`);
+        return false;
+    }
+    try {
+        const parsedDate = parseDateFromFilePath(relativePath, filename, structure, shouldParseTime, logger);
+        if (parsedDate) {
+            // Apply date range filtering
+            if (isDateInRange(parsedDate, dateRange)) {
+                logger.debug('Processing file %s with date %s', filePath, parsedDate.toISOString());
+                await callback(filePath, parsedDate);
+                return true;
+            } else {
+                const dateRangeDisplay = dateRange ? `from ${dateRange.start ? new Date(dateRange.start).toISOString() : 'beginning'} up to ${dateRange.end ? new Date(dateRange.end).toISOString() : 'end'}` : 'all dates';
+                logger.debug('Skipping file %s, date %s out of range %s', filePath, parsedDate.toISOString(), dateRangeDisplay);
+            }
+        } else {
+            logger.warn('Could not parse date for file %s with structure "%s" (filename base: "%s", path parts: %s)', filePath, structure, path.basename(filename, path.extname(filename)), pathParts.join('/'));
+        }
+    } catch (error) {
+        // Log error from the callback or date parsing/filtering itself
+        if (error instanceof Error) {
+            logger.error('Error processing file %s: %s\n%s', filePath, error.message, error.stack);
+        } else {
+            logger.error('Error processing file %s: %s', filePath, error);
+        }
+    }
+    return false;
+};
+const process = async (inputStructure, inputFilenameOptions, extensions, timezone, start, end, limit, features, logger, inputDirectory, callback, concurrency)=>{
+    var _ref;
+    const storage = create({
+        log: logger.debug
+    });
+    const dateRange = calculateDateRange(timezone, start, end);
+    let fileCount = 0;
+    // Validate date range dates if provided
+    if ((dateRange === null || dateRange === void 0 ? void 0 : dateRange.start) && (!dateRange.start || isNaN(dateRange.start.getTime()))) {
+        logger.warn(`Invalid start date provided in dateRange: ${dateRange.start}`);
+    }
+    if ((dateRange === null || dateRange === void 0 ? void 0 : dateRange.end) && (!dateRange.end || isNaN(dateRange.end.getTime()))) {
+        logger.warn(`Invalid end date provided in dateRange: ${dateRange.end}`);
+    }
+    // Structured Input Logic
+    const structure = inputStructure !== null && inputStructure !== void 0 ? inputStructure : 'none'; // Default to 'none' if not specified
+    logger.info(`Processing structured input with structure "${structure}" in %s for date range: ${JSON.stringify(dateRange)}`, inputDirectory);
+    // Determine if time should be parsed from filenames
+    const shouldParseTime = (_ref = inputFilenameOptions === null || inputFilenameOptions === void 0 ? void 0 : inputFilenameOptions.includes('time')) !== null && _ref !== void 0 ? _ref : false;
+    if (shouldParseTime) {
+        logger.debug('Filename time parsing enabled based on inputFilenameOptions.');
+    } else {
+        logger.debug('Filename time parsing disabled; defaulting times to 00:00 UTC.');
+    }
+    const filePattern = getFilePattern(features, extensions || [], logger);
+    logger.debug('Processing Structured Input with pattern %s from %s', filePattern, inputDirectory);
+    await storage.forEachFileIn(inputDirectory, async (filePath)=>{
+        const processed = await processStructuredFile(filePath, inputDirectory, structure, shouldParseTime, callback, filePattern, dateRange, logger);
+        if (processed) {
+            fileCount++;
+        }
+    }, {
+        pattern: filePattern,
+        limit,
+        concurrency
+    });
+    return fileCount;
+};
+
+export { calculateDateRange, getFilePattern, isDateInRange, parseDateFromFilePath, parseDateFromString, process, processStructuredFile };
+//# sourceMappingURL=structured.js.map

package/dist/input/structured.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured.js","sources":["../../src/input/structured.ts"],"sourcesContent":["import { Feature, FilenameOption, FilesystemStructure, Logger } from 'dreadcabinet';\nimport * as path from 'node:path';\nimport { z } from 'zod';\nimport { ArgumentError } from \"../configure\";\nimport { DATE_FORMAT_YEAR_MONTH_DAY } from '../constants';\nimport * as Dates from \"../util/dates\";\nimport * as Storage from \"../util/storage\";\n\nexport const DateRangeSchema = z.object({\n    start: z.date(),\n    end: z.date(),\n});\n\nexport type DateRange = z.infer<typeof DateRangeSchema>;\n\n// Get the appropriate file pattern based on config and options\nexport const getFilePattern = (features: Feature[], extensions: string[], logger: Logger): string => {\n    // Validate extensions: they should not start with a dot.\n    if (extensions && extensions.length > 0) {\n        for (const ext of extensions) {\n            if (ext.startsWith('.')) {\n                // Throw an error as the dot is added automatically by the pattern generation.\n                // Using ArgumentError might be more consistent if available and appropriate here.\n                throw new Error(`Invalid extension format: \"${ext}\". Extensions should not start with a dot ('.').`);\n            }\n        }\n    }\n\n    let pattern = '**/*'; // Start with a broad pattern for recursive search\n    if (features.includes('extensions') && extensions && extensions.length > 0) {\n        if (extensions.length === 1) {\n            pattern = `**/*.${extensions[0]}`;\n        } else {\n            pattern = `**/*.{${extensions.join(',')}}`;\n        }\n        logger.debug(`Applying extension filter: ${extensions.join(',')}`);\n    } else {\n        pattern = `**/*.*`;\n        logger.debug(`No extension filter applied, using pattern: ${pattern}`);\n    }\n    return pattern;\n};\n\n\n// Helper function to parse date string based on expected format\n// Returns null if parsing fails\nexport const parseDateFromString = (\n    dateStr: string,\n    format: 'YYYY-M-D-HHmm' | 'M-D-HHmm' | 'D-HHmm' | 'HHmm',\n    shouldParseTime: boolean, // New required parameter\n    year?: number,\n    month?: number,\n    day?: number\n): Date | null => {\n    // Basic validation\n    if (!dateStr) return null;\n\n    try {\n        let y = year ?? 0;\n        let mo = month ?? 0; // JS months are 0-indexed\n        let d = day ?? 1; // JS days are 1-indexed\n        let h = 0; // Default to 0\n        let mi = 0; // Default to 0\n\n        // Remove potential leading/trailing non-alphanumeric if needed, split by common separators\n        const cleanedDateStr = dateStr.replace(/^[^\\p{L}\\p{N}]+|[^\\p{L}\\p{N}]+$/gu, '');\n        const parts = cleanedDateStr.split(/[-_]/); // Allow dash or underscore\n\n        switch (format) {\n            case 'YYYY-M-D-HHmm': {\n                if (parts.length < 4 && shouldParseTime) return null; // Need time part if parsing it\n                if (parts.length < 3 && !shouldParseTime) return null; // Need at least date part\n                y = parseInt(parts[0], 10);\n                mo = parseInt(parts[1], 10) - 1; // Adjust month\n                d = parseInt(parts[2], 10);\n                if (shouldParseTime) {\n                    const timePartYD = parts[3];\n                    if (timePartYD.length < 4) return null; // Ensure HHmm exists\n                    h = parseInt(timePartYD.substring(0, 2), 10);\n                    mi = parseInt(timePartYD.substring(2, 4), 10);\n                }\n                break;\n            }\n            case 'M-D-HHmm': {\n                if (year === undefined) return null;\n                if (parts.length < 3 && shouldParseTime) return null;\n                if (parts.length < 2 && !shouldParseTime) return null;\n                mo = parseInt(parts[0], 10) - 1; // Adjust month\n                d = parseInt(parts[1], 10);\n                if (shouldParseTime) {\n                    const timePartMD = parts[2];\n                    if (timePartMD.length < 4) return null; // Ensure HHmm exists\n                    h = parseInt(timePartMD.substring(0, 2), 10);\n                    mi = parseInt(timePartMD.substring(2, 4), 10);\n                }\n                break;\n            }\n            case 'D-HHmm': {\n                if (year === undefined || month === undefined) return null;\n                if (parts.length < 2 && shouldParseTime) return null;\n                if (parts.length < 1 && !shouldParseTime) return null;\n                d = parseInt(parts[0], 10);\n                if (shouldParseTime) {\n                    const timePartD = parts[1];\n                    if (timePartD.length < 4) return null; // Ensure HHmm exists\n                    h = parseInt(timePartD.substring(0, 2), 10);\n                    mi = parseInt(timePartD.substring(2, 4), 10);\n                }\n                break;\n            }\n            case 'HHmm':\n                if (year === undefined || month === undefined || day === undefined) return null;\n                if (shouldParseTime) {\n                    if (parts[0].length !== 4) return null;\n                    h = parseInt(parts[0].substring(0, 2), 10);\n                    mi = parseInt(parts[0].substring(2, 4), 10);\n                } // Else h=0, mi=0 (set by defaults)\n                break;\n            default:\n                return null;\n        }\n\n        // Validate parsed numbers\n        if (isNaN(y) || isNaN(mo) || isNaN(d)) {\n            throw new Error(`Invalid date components in date string \"${dateStr}\" with format ${format}: Y:${y} M:${mo} D:${d}`);\n        }\n\n        // Set hour and minute to 0 if not provided\n        if (isNaN(h)) {\n            h = 0;\n        }\n        if (isNaN(mi)) {\n            mi = 0;\n        }\n\n        if (mo < 0 || mo > 11 || d < 1 || d > 31 || h < 0 || h > 23 || mi < 0 || mi > 59) {\n            throw new Error(`Invalid date components in date string \"${dateStr}\" with format ${format}: Y:${y} M:${mo + 1} D:${d} H:${h} m:${mi}`);\n        }\n\n\n\n\n        const date = new Date(Date.UTC(y, mo, d, h, mi));\n        // Double check components as Date object might adjust invalid dates (e.g. Feb 30th -> Mar 2nd)\n        if (date.getUTCFullYear() !== y || date.getUTCMonth() !== mo || date.getUTCDate() !== d || date.getUTCHours() !== h || date.getUTCMinutes() !== mi) {\n            // console.debug(`Date validation failed for Y:${y} M:${mo} D:${d} H:${h} m:${mi}. JS Date adjusted it.`);\n            return null;\n        }\n\n        return date;\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e) {\n        // console.error(`Error parsing date string \"${dateStr}\" with format ${format}:`, e);\n        return null;\n    }\n};\n\n// Helper to check if date is within range (start inclusive, end exclusive)\nexport const isDateInRange = (date: Date, range?: DateRange): boolean => {\n    if (!range || (!range.start && !range.end)) return true; // No range or empty range means all dates are valid\n\n    // Ensure range dates are Date objects\n    const startDate = range.start ? (range.start instanceof Date ? range.start : new Date(range.start)) : null;\n    const endDate = range.end ? (range.end instanceof Date ? range.end : new Date(range.end)) : null;\n\n    // Validate parsed range dates\n    const isStartDateValid = startDate && !isNaN(startDate.getTime());\n    const isEndDateValid = endDate && !isNaN(endDate.getTime());\n\n\n    if (isStartDateValid && date < startDate!) {\n        return false;\n    }\n    // End date is exclusive\n    if (isEndDateValid && date >= endDate!) {\n        return false;\n    }\n    return true;\n};\n\nexport const calculateDateRange = (timezone: string, startDate: Date, endDate: Date): DateRange => {\n\n    // Create date utility after timezone is validated\n    const dateUtil = Dates.create({ timezone });\n\n    const now = dateUtil.now();\n    const range: DateRange = {\n        start: dateUtil.subDays(now, 31),\n        end: now,\n    }\n\n    // Note: Validation ensures dates are valid and start <= end if both are provided\n    if (startDate || endDate) {\n\n        // Handle end date\n        if (endDate) {\n            range.end = dateUtil.parse(endDate, DATE_FORMAT_YEAR_MONTH_DAY);\n        }\n\n        // Handle start date\n        if (startDate) {\n            range.start = dateUtil.parse(startDate, DATE_FORMAT_YEAR_MONTH_DAY);\n        }\n\n        // We re-check the order here after defaults might have been applied,\n        // although validateStartEndDates should catch explicit invalid orders.\n        if (dateUtil.isBefore(range.end, range.start)) {\n            // This case should theoretically not be reachable due to prior validation\n            // but is kept as a safeguard.\n            throw new ArgumentError('--start', `Start date (${dateUtil.format(range.start, DATE_FORMAT_YEAR_MONTH_DAY)}) cannot be after end date (${dateUtil.format(range.end, DATE_FORMAT_YEAR_MONTH_DAY)}).`);\n        }\n\n    }\n\n    return range;\n}\n\n\n\n// Parse date from file path based on the input structure\nexport const parseDateFromFilePath = (\n    relativePath: string,\n    filename: string,\n    structure: string,\n    shouldParseTime: boolean,\n    logger: Logger\n): Date | null => {\n    const pathParts = relativePath.split(path.sep);\n    const filenameWithoutExt = path.basename(filename, path.extname(filename));\n\n    let parsedDate: Date | null = null;\n    let year: number | undefined;\n    let month: number | undefined; // 0-indexed month for Date constructor\n    let day: number | undefined;\n\n    switch (structure) {\n        case 'none':\n            // Filename format: YYYY-M-D-HHmm...\n            parsedDate = parseDateFromString(filenameWithoutExt, 'YYYY-M-D-HHmm', shouldParseTime);\n            break;\n        case 'year':\n            // Path: YYYY / M-D-HHmm...\n            if (pathParts.length >= 1) {\n                year = parseInt(pathParts[0], 10);\n                if (!isNaN(year)) {\n                    parsedDate = parseDateFromString(filenameWithoutExt, 'M-D-HHmm', shouldParseTime, year);\n                } else {\n                    logger.warn(`Invalid year format in path: ${pathParts[0]}`);\n                }\n            } else {\n                logger.warn(`File path does not match expected 'year' structure (YYYY/...)`);\n            }\n            break;\n        case 'month':\n            // Path: YYYY / MM / D-HHmm...\n            if (pathParts.length >= 2) {\n                year = parseInt(pathParts[0], 10);\n                const monthDir = parseInt(pathParts[1], 10); // Month from dir (1-indexed)\n                if (!isNaN(year) && !isNaN(monthDir) && monthDir >= 1 && monthDir <= 12) {\n                    month = monthDir - 1; // Adjust month for Date object (0-indexed)\n                    parsedDate = parseDateFromString(filenameWithoutExt, 'D-HHmm', shouldParseTime, year, month);\n                } else {\n                    logger.warn(`Invalid year/month format in path: ${pathParts[0]}/${pathParts[1]}`);\n                }\n            } else {\n                logger.warn(`File path does not match expected 'month' structure (YYYY/MM/...)`);\n            }\n            break;\n        case 'day':\n            // Path: YYYY / MM / DD / HHmm...\n            if (pathParts.length >= 3) {\n                year = parseInt(pathParts[0], 10);\n                const monthDir = parseInt(pathParts[1], 10); // Month from dir (1-indexed)\n                day = parseInt(pathParts[2], 10); // Day from dir (1-indexed)\n                if (!isNaN(year) && !isNaN(monthDir) && monthDir >= 1 && monthDir <= 12 && !isNaN(day) && day >= 1 && day <= 31) {\n                    month = monthDir - 1; // Adjust month (0-indexed)\n                    parsedDate = parseDateFromString(filenameWithoutExt, 'HHmm', shouldParseTime, year, month, day);\n                } else {\n                    logger.warn(`Invalid year/month/day format in path: ${pathParts[0]}/${pathParts[1]}/${pathParts[2]}`);\n                }\n            } else {\n                logger.warn(`File path does not match expected 'day' structure (YYYY/MM/DD/...)`);\n            }\n            break;\n        default:\n            logger.error(`Fatal: Unknown input structure \"${structure}\" specified in config.`);\n            throw new Error(`Unknown input structure \"${structure}\" specified.`);\n    }\n\n    return parsedDate;\n};\n\n// Process a single file from the structured input\nexport const processStructuredFile = async (\n    filePath: string,\n    inputDirectory: string,\n    structure: string,\n    shouldParseTime: boolean,\n    callback: (file: string, date?: Date) => Promise<void>,\n    pattern: string,\n    dateRange: DateRange,\n    logger: Logger\n): Promise<boolean> => {\n    // Skip if filePath somehow points to the inputDirectory itself or is not a file\n    if (filePath === inputDirectory || !path.extname(filePath) && pattern.endsWith('*.*')) {\n        return false;\n    }\n\n    const relativePath = path.relative(inputDirectory, filePath);\n    const pathParts = relativePath.split(path.sep);\n    const filename = pathParts.pop(); // Filename is the last part\n\n    if (!filename) {\n        logger.warn(`Could not determine filename for path: ${filePath}`);\n        return false;\n    }\n\n    try {\n        const parsedDate = parseDateFromFilePath(relativePath, filename, structure, shouldParseTime, logger);\n\n        if (parsedDate) {\n            // Apply date range filtering\n            if (isDateInRange(parsedDate, dateRange)) {\n                logger.debug('Processing file %s with date %s', filePath, parsedDate.toISOString());\n                await callback(filePath, parsedDate);\n                return true;\n            } else {\n                const dateRangeDisplay = dateRange ?\n                    `from ${dateRange.start ? new Date(dateRange.start).toISOString() : 'beginning'} up to ${dateRange.end ? new Date(dateRange.end).toISOString() : 'end'}` :\n                    'all dates';\n                logger.debug('Skipping file %s, date %s out of range %s', filePath, parsedDate.toISOString(), dateRangeDisplay);\n            }\n        } else {\n            logger.warn('Could not parse date for file %s with structure \"%s\" (filename base: \"%s\", path parts: %s)',\n                filePath, structure, path.basename(filename, path.extname(filename)), pathParts.join('/'));\n        }\n    } catch (error) {\n        // Log error from the callback or date parsing/filtering itself\n        if (error instanceof Error) {\n            logger.error('Error processing file %s: %s\\n%s', filePath, error.message, error.stack);\n        } else {\n            logger.error('Error processing file %s: %s', filePath, error);\n        }\n    }\n\n    return false;\n};\n\nexport const process = async (\n    inputStructure: FilesystemStructure,\n    inputFilenameOptions: FilenameOption[],\n    extensions: string[],\n    timezone: string,\n    start: Date,\n    end: Date,\n    limit: number | undefined,\n    features: Feature[],\n    logger: Logger,\n    inputDirectory: string,\n    callback: (file: string, date?: Date) => Promise<void>,\n    concurrency?: number\n): Promise<number> => {\n    const storage = Storage.create({ log: logger.debug });\n    const dateRange = calculateDateRange(timezone, start, end);\n\n    let fileCount = 0;\n\n    // Validate date range dates if provided\n    if (dateRange?.start && (!dateRange.start || isNaN(dateRange.start.getTime()))) {\n        logger.warn(`Invalid start date provided in dateRange: ${dateRange.start}`);\n    }\n    if (dateRange?.end && (!dateRange.end || isNaN(dateRange.end.getTime()))) {\n        logger.warn(`Invalid end date provided in dateRange: ${dateRange.end}`);\n    }\n\n    // Structured Input Logic\n    const structure = inputStructure ?? 'none'; // Default to 'none' if not specified\n    logger.info(`Processing structured input with structure \"${structure}\" in %s for date range: ${JSON.stringify(dateRange)}`, inputDirectory);\n\n    // Determine if time should be parsed from filenames\n    const shouldParseTime = inputFilenameOptions?.includes('time') ?? false;\n    if (shouldParseTime) {\n        logger.debug('Filename time parsing enabled based on inputFilenameOptions.');\n    } else {\n        logger.debug('Filename time parsing disabled; defaulting times to 00:00 UTC.');\n    }\n\n    const filePattern = getFilePattern(features, extensions || [], logger);\n\n    logger.debug('Processing Structured Input with pattern %s from %s', filePattern, inputDirectory);\n\n    await storage.forEachFileIn(inputDirectory, async (filePath: string) => {\n        const processed = await processStructuredFile(\n            filePath,\n            inputDirectory,\n            structure,\n            shouldParseTime,\n            callback,\n            filePattern,\n            dateRange,\n            logger\n        );\n\n        if (processed) {\n            fileCount++;\n        }\n    }, { pattern: filePattern, limit, concurrency } as { pattern: string, limit?: number, concurrency?: number });\n\n    return fileCount;\n}\n\n\n\n\n"],"names":["z","object","start","date","end","getFilePattern","features","extensions","logger","length","ext","startsWith","Error","pattern","includes","join","debug","parseDateFromString","dateStr","format","shouldParseTime","year","month","day","y","mo","d","h","mi","cleanedDateStr","replace","parts","split","parseInt","timePartYD","substring","undefined","timePartMD","timePartD","isNaN","Date","UTC","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","e","isDateInRange","range","startDate","endDate","isStartDateValid","getTime","isEndDateValid","calculateDateRange","timezone","dateUtil","Dates","now","subDays","parse","DATE_FORMAT_YEAR_MONTH_DAY","isBefore","ArgumentError","parseDateFromFilePath","relativePath","filename","structure","pathParts","path","sep","filenameWithoutExt","basename","extname","parsedDate","warn","monthDir","error","processStructuredFile","filePath","inputDirectory","callback","dateRange","endsWith","relative","pop","toISOString","dateRangeDisplay","message","stack","process","inputStructure","inputFilenameOptions","limit","concurrency","storage","Storage","log","fileCount","info","JSON","stringify","filePattern","forEachFileIn","processed"],"mappings":"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"}

package/dist/input/unstructured.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '../dreadcabinet';
+export declare const process: (inputDirectory: string, recursive: boolean, extensions: string[], limit: number | undefined, logger: Logger, callback: (file: string) => Promise<void>, concurrency?: number) => Promise<number>;

package/dist/input/unstructured.js

@@ -0,0 +1,45 @@
+import { create } from '../util/storage.js';
+
+// Process files with unstructured input pattern
+const process = async (inputDirectory, recursive, extensions, limit, logger, callback, concurrency)=>{
+    const storage = create({
+        log: logger.debug
+    });
+    let fileCount = 0;
+    let filePattern = `${recursive ? '**/' : ''}*`;
+    if (extensions && extensions.length > 0) {
+        // Ensure the pattern correctly handles extensions with or without recursion
+        if (recursive) {
+            filePattern = `**/*.{${extensions.join(',')}}`;
+        } else {
+            filePattern = `*.{${extensions.join(',')}}`;
+        }
+        logger.debug(`Applying extension filter: ${extensions.join(',')}`);
+    } else if (!recursive) {
+        // Non-recursive without extension filter: only files in the top directory
+        filePattern = `*.*`; // Adjust if files without extensions need matching
+    }
+    logger.info('Processing unstructured files %s in %s with pattern %s', recursive ? 'recursively' : 'non-recursively', inputDirectory, filePattern);
+    await storage.forEachFileIn(inputDirectory, async (file)=>{
+        try {
+            logger.debug('Processing file %s', file);
+            // Call callback without date for unstructured input
+            await callback(file); // Pass undefined for the date parameter
+            fileCount++;
+        } catch (error) {
+            if (error instanceof Error) {
+                logger.error('Error processing file %s: %s\n%s', file, error.message, error.stack);
+            } else {
+                logger.error('Error processing file %s: %s', file, error);
+            }
+        }
+    }, {
+        pattern: filePattern,
+        limit,
+        concurrency
+    });
+    return fileCount;
+};
+
+export { process };
+//# sourceMappingURL=unstructured.js.map