@cogeotiff/cli 7.2.1 → 8.0.2

package/build/cli.log.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.log.d.ts","sourceRoot":"","sources":["../src/cli.log.ts"],"names":[],"mappings":";AAGA,eAAO,MAAM,MAAM,qDAAiE,CAAC"}

package/build/cli.log.js

@@ -1,4 +0,0 @@
-import pino from 'pino';
-import { PrettyTransform } from 'pretty-json-log';
-export const logger = process.stdout.isTTY ? pino(PrettyTransform.stream()) : pino();
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpLmxvZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9jbGkubG9nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sSUFBSSxNQUFNLE1BQU0sQ0FBQztBQUN4QixPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFbEQsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHBpbm8gZnJvbSAncGlubyc7XG5pbXBvcnQgeyBQcmV0dHlUcmFuc2Zvcm0gfSBmcm9tICdwcmV0dHktanNvbi1sb2cnO1xuXG5leHBvcnQgY29uc3QgbG9nZ2VyID0gcHJvY2Vzcy5zdGRvdXQuaXNUVFkgPyBwaW5vKFByZXR0eVRyYW5zZm9ybS5zdHJlYW0oKSkgOiBwaW5vKCk7XG4iXX0=

package/build/cli.table.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.table.d.ts","sourceRoot":"","sources":["../src/cli.table.ts"],"names":[],"mappings":"AAAA,UAAU,YAAY,CAAC,CAAC;IACpB,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,0BAA0B;IAC1B,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IAC/C;;;OAGG;IACH,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC;CACjC;AAED,qBAAa,QAAQ,CAAC,CAAC;IACnB,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,CAAM;IAC/B,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI;IAIlC,KAAK,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,UAAU,SAAK,GAAG,MAAM,EAAE;CAa9C"}

package/build/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,gCAAgC,CAAC"}

package/build/util.bytes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"util.bytes.d.ts","sourceRoot":"","sources":["../src/util.bytes.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQtD"}

package/build/util.tile.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"util.tile.d.ts","sourceRoot":"","sources":["../src/util.tile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAgB,MAAM,iBAAiB,CAAC;AAGxD,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAU7B;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAUzF;AAED,wBAAsB,SAAS,CAC3B,GAAG,EAAE,OAAO,EACZ,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,IAAI,CAAC,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC,CASf"}

package/src/action.dump.tile.ts

@@ -1,240 +0,0 @@
-import { CogTiff, TiffVersion } from '@cogeotiff/core';
-import { CommandLineAction, CommandLineIntegerParameter, CommandLineStringParameter } from '@rushstack/ts-command-line';
-import c from 'ansi-colors';
-import { promises as fs } from 'fs';
-import * as path from 'path';
-import { ActionUtil, CliResultMap } from './action.util.js';
-import { logger as CliLogger } from './cli.log.js';
-import { toByteSizeString } from './util.bytes.js';
-import { getTileName, writeTile } from './util.tile.js';
-import PLimit from 'p-limit';
-import { ChunkSourceBase } from '@chunkd/core';
-import pino from 'pino';
-
-const Rad2Deg = 180 / Math.PI;
-const A = 6378137.0; // 900913 properties.
-function toLatLng(x: number, y: number): [number, number] {
-    return [(x * Rad2Deg) / A, (Math.PI * 0.5 - 2.0 * Math.atan(Math.exp(-y / A))) * Rad2Deg];
-}
-
-const TileQueue = PLimit(25);
-
-export interface GeoJsonPolygon {
-    type: 'Feature';
-    geometry: {
-        type: 'Polygon';
-        coordinates: [[[number, number], [number, number], [number, number], [number, number], [number, number]]];
-    };
-    properties: Record<string, unknown>;
-}
-
-function makePolygon(xMin: number, yMin: number, xMax: number, yMax: number): GeoJsonPolygon {
-    const [lngMin, latMin] = toLatLng(xMin, yMin);
-    const [lngMax, latMax] = toLatLng(xMax, yMax);
-
-    return {
-        type: 'Feature',
-        properties: {},
-        geometry: {
-            type: 'Polygon',
-            coordinates: [
-                [
-                    [lngMin, latMin],
-                    [lngMin, latMax],
-                    [lngMax, latMax],
-                    [lngMax, latMin],
-                    [lngMin, latMin],
-                ],
-            ],
-        },
-    };
-}
-
-export class ActionDumpTile extends CommandLineAction {
-    private file: CommandLineStringParameter | null = null;
-    private imageIndex: CommandLineIntegerParameter | null = null;
-    private output: CommandLineStringParameter | null = null;
-    private outputCount = 0;
-    private logger: pino.Logger;
-
-    public constructor() {
-        super({
-            actionName: 'dump',
-            summary: 'Dump tiles from a COG',
-            documentation: 'Stuff',
-        });
-        this.logger = CliLogger.child({ action: 'tile' });
-    }
-
-    // TODO this only works for WSG84
-    async dumpBounds(tif: CogTiff, output: string, index: number): Promise<void> {
-        this.logger.info({ index }, 'CreateTileBounds');
-        const img = tif.getImage(index);
-        if (!img.isTiled() || !img.isGeoLocated) return;
-
-        const features: GeoJsonPolygon[] = [];
-        const featureCollection = {
-            type: 'FeatureCollection',
-            features,
-        };
-
-        const tileCount = img.tileCount;
-        const tileInfo = img.tileSize;
-        const tileSize = img.size;
-
-        const firstImage = tif.images[0];
-        const firstTileSize = firstImage.size;
-        const origin = firstImage.origin;
-        const resolution = firstImage.resolution;
-
-        const xScale = (resolution[0] * firstTileSize.width) / tileSize.width;
-        const yScale = (resolution[1] * firstTileSize.height) / tileSize.height;
-
-        for (let y = 0; y < tileCount.y; y++) {
-            const yMax = origin[1] + y * tileInfo.height * yScale;
-            const yMin = yMax + tileInfo.height * yScale;
-            for (let x = 0; x < tileCount.x; x++) {
-                const xMin = origin[0] + x * tileInfo.width * xScale;
-                const xMax = xMin + tileInfo.width * xScale;
-                features.push(makePolygon(xMin, yMin, xMax, yMax));
-            }
-        }
-
-        await fs.writeFile(path.join(output, `i${index}.bounds.geojson`), JSON.stringify(featureCollection, null, 2));
-    }
-
-    async dumpIndex(tif: CogTiff, output: string, index: number): Promise<void> {
-        this.logger.info({ index }, 'CreateIndexHtml');
-        const img = tif.getImage(index);
-        if (!img.isTiled()) {
-            return;
-        }
-
-        const { tileCount, tileSize } = img;
-
-        const styles = `<style>.c { min-width: ${tileSize.width}px; min-height: ${tileSize.height}px }</style>`;
-
-        const html = ['<html>', styles];
-        for (let y = 0; y < tileCount.y; y++) {
-            html.push('\t<div style="display:flex;">');
-            for (let x = 0; x < tileCount.x; x++) {
-                const tile = await tif.getTile(x, y, index);
-                if (tile == null) {
-                    html.push(`\t\t<div class="c"></div>`);
-                    continue;
-                }
-
-                html.push(`\t\t<img class="c" src="./${getTileName(tile.mimeType, index, x, y)}" >`);
-            }
-
-            html.push('\t</div>');
-        }
-        html.push('</html>');
-        await fs.writeFile(path.join(output, 'index.html'), html.join('\n'));
-    }
-
-    async dumpTiles(tif: CogTiff, output: string, index: number): Promise<void> {
-        const promises: Promise<void>[] = [];
-        const img = tif.getImage(index);
-        if (!img.isTiled()) {
-            return;
-        }
-
-        this.logger.info({ ...img.tileSize, ...img.tileCount }, 'TileInfo');
-        const tileCount = img.tileCount;
-
-        // Load all offsets in
-        await img.tileOffset.load();
-
-        for (let x = 0; x < tileCount.x; x++) {
-            for (let y = 0; y < tileCount.y; y++) {
-                const promise = TileQueue(() => writeTile(tif, x, y, index, output, this.logger));
-                promises.push(promise);
-                this.outputCount++;
-            }
-        }
-
-        await Promise.all(promises);
-    }
-
-    async onExecute(): Promise<void> {
-        if (
-            this.imageIndex == null ||
-            this.imageIndex.value == null ||
-            this.output == null ||
-            this.output.value == null
-        ) {
-            return;
-        }
-        this.outputCount = 0;
-
-        const { tif } = await ActionUtil.getCogSource(this.file);
-        const index = this.imageIndex.value;
-        if (index == null || index > tif.images.length - 1 || index < -1) {
-            this.renderHelpText();
-            throw Error(`Invalid index level "${index}" must be between 0 - ${tif.images.length - 1}`);
-        }
-
-        const img = tif.getImage(index);
-        if (!img.isTiled()) {
-            throw Error('Tif file is not tiled.');
-        }
-
-        const output = path.join(this.output.value, `i${index}`);
-        await fs.mkdir(output, { recursive: true });
-
-        await this.dumpTiles(tif, output, index);
-        await this.dumpIndex(tif, output, index);
-        await this.dumpBounds(tif, this.output.value, index);
-
-        const source = tif.source as ChunkSourceBase;
-        const chunkIds = [...(source.chunks as Map<unknown, unknown>).values()];
-        const result: CliResultMap[] = [
-            {
-                keys: [
-                    { key: 'Tiff type', value: `${TiffVersion[tif.version]} (v${String(tif.version)})` },
-                    { key: 'Chunk size', value: toByteSizeString(tif.source.chunkSize) },
-                    {
-                        key: 'Bytes read',
-                        value:
-                            `${toByteSizeString(chunkIds.length * tif.source.chunkSize)} ` +
-                            `(${chunkIds.length} Chunk${chunkIds.length === 1 ? '' : 's'})`,
-                    },
-                ],
-            },
-            {
-                title: 'Output',
-                keys: [{ key: 'Images', value: this.outputCount }],
-            },
-        ];
-        const msg = ActionUtil.formatResult(`${c.bold('COG File Info')} - ${c.bold(tif.source.uri)}`, result);
-        console.log(msg.join('\n'));
-        return Promise.resolve();
-    }
-
-    protected onDefineParameters(): void {
-        this.file = this.defineStringParameter({
-            argumentName: 'FILE',
-            parameterLongName: '--file',
-            parameterShortName: '-f',
-            description: 'cog file to access',
-            required: true,
-        });
-
-        this.imageIndex = this.defineIntegerParameter({
-            argumentName: 'IMAGE',
-            parameterShortName: '-i',
-            parameterLongName: '--image',
-            description: 'Image id to export (starting from 0)',
-            required: true,
-        });
-
-        this.output = this.defineStringParameter({
-            argumentName: 'OUTPUT',
-            parameterShortName: '-o',
-            parameterLongName: '--output',
-            description: 'Where to store the output',
-            required: true,
-        });
-    }
-}

package/src/action.info.ts

@@ -1,205 +0,0 @@
-import { ChunkSourceBase } from '@chunkd/core';
-import { CogTiffImage, TiffTag, TiffTagGeo, TiffVersion } from '@cogeotiff/core';
-import { CommandLineAction, CommandLineFlagParameter, CommandLineStringParameter } from '@rushstack/ts-command-line';
-import c from 'ansi-colors';
-import { ActionUtil, CliResultMap } from './action.util.js';
-import { CliTable } from './cli.table.js';
-import { toByteSizeString } from './util.bytes.js';
-
-function formatTag(tagId: TiffTag | TiffTagGeo, tagName: string, tagValue: any): { key: string; value: string } {
-    const key = `${String(tagId).padEnd(7, ' ')} ${String(tagName).padEnd(20)}`;
-
-    if (Array.isArray(tagValue)) {
-        return { key, value: tagValue.slice(0, 250).join(', ') };
-    }
-    return { key, value: String(tagValue).substr(0, 1024) };
-}
-
-function round(num: number): number {
-    const opt = 10 ** 4;
-    return Math.floor(num * opt) / opt;
-}
-
-const TiffImageInfoTable = new CliTable<CogTiffImage>();
-TiffImageInfoTable.add({ name: 'Id', width: 4, get: (i, index) => String(index) });
-TiffImageInfoTable.add({ name: 'Size', width: 20, get: (i) => `${i.size.width}x${i.size.height}` });
-TiffImageInfoTable.add({
-    name: 'Tile Size',
-    width: 20,
-    get: (i) => `${i.tileCount.x}x${i.tileCount.y}`,
-    enabled: (i) => i.isTiled(),
-});
-TiffImageInfoTable.add({
-    name: 'Tile Count',
-    width: 20,
-    get: (i) => `${i.tileCount.x * i.tileCount.y}`,
-    enabled: (i) => i.isTiled(),
-});
-TiffImageInfoTable.add({
-    name: 'Strip Count',
-    width: 20,
-    get: (i) => `${i.tags.get(TiffTag.StripOffsets)?.dataCount}`,
-    enabled: (i) => !i.isTiled(),
-});
-TiffImageInfoTable.add({
-    name: 'Resolution',
-    width: 20,
-    get: (i) => `${round(i.resolution[0])}`,
-    enabled: (i) => i.isGeoLocated,
-});
-
-// Show compression only if it varies between images
-TiffImageInfoTable.add({
-    name: 'Compression',
-    width: 20,
-    get: (i) => i.compression,
-    enabled: (i) => {
-        const formats = new Set();
-        i.tif.images.forEach((f) => formats.add(f.compression));
-        return formats.size > 1;
-    },
-});
-
-/**
- * Parse out the GDAL Metadata to be more friendly to read
- *
- * TODO using a XML Parser will make this even better
- * @param img
- */
-function parseGdalMetadata(img: CogTiffImage): string[] | null {
-    const metadata = img.value(TiffTag.GDAL_METADATA);
-    if (typeof metadata !== 'string') return null;
-    if (!metadata.startsWith('<GDALMetadata>')) return null;
-    return metadata
-        .replace('<GDALMetadata>\n', '')
-        .replace('</GDALMetadata>\n', '')
-        .replace('\n\x00', '')
-        .split('\n')
-        .map((c) => c.trim());
-}
-
-export class ActionCogInfo extends CommandLineAction {
-    private file?: CommandLineStringParameter;
-    private tags?: CommandLineFlagParameter;
-    private tagsAll?: CommandLineFlagParameter;
-
-    public constructor() {
-        super({
-            actionName: 'info',
-            summary: 'Shows info about a COG',
-            documentation: '',
-        });
-    }
-
-    async onExecute(): Promise<void> {
-        const { tif } = await ActionUtil.getCogSource(this.file);
-        const [firstImage] = tif.images;
-
-        await firstImage.loadGeoTiffTags();
-
-        const source = tif.source as ChunkSourceBase;
-        const chunkIds = [...(source.chunks as Map<unknown, unknown>).values()];
-
-        const imageInfo = '\n' + TiffImageInfoTable.print(tif.images, '\t\t').join('\n');
-
-        const gdalMetadata = parseGdalMetadata(firstImage);
-        const ghostOptions = [...tif.options.options.entries()];
-
-        const isGeoLocated = firstImage.isGeoLocated;
-
-        const result: CliResultMap[] = [
-            {
-                keys: [
-                    { key: 'Tiff type', value: `${TiffVersion[tif.version]} (v${String(tif.version)})` },
-                    { key: 'Chunk size', value: toByteSizeString(tif.source.chunkSize) },
-                    {
-                        key: 'Bytes read',
-                        value: `${toByteSizeString(chunkIds.length * tif.source.chunkSize)} (${chunkIds.length} Chunk${
-                            chunkIds.length === 1 ? '' : 's'
-                        })`,
-                    },
-                ],
-            },
-            {
-                title: 'Images',
-                keys: [
-                    { key: 'Compression', value: firstImage.compression },
-                    isGeoLocated ? { key: 'Origin', value: firstImage.origin.map(round).join(', ') } : null,
-                    isGeoLocated ? { key: 'Resolution', value: firstImage.resolution.map(round).join(', ') } : null,
-                    isGeoLocated ? { key: 'BoundingBox', value: firstImage.bbox.map(round).join(', ') } : null,
-                    firstImage.epsg
-                        ? { key: 'EPSG', value: `EPSG:${firstImage.epsg} (https://epsg.io/${firstImage.epsg})` }
-                        : null,
-                    { key: 'Info', value: imageInfo },
-                ],
-            },
-            {
-                title: 'GDAL',
-                keys: [
-                    { key: 'COG optimized', value: tif.options.isCogOptimized },
-                    tif.options.isBroken ? { key: 'COG broken', value: tif.options.isBroken } : null,
-                    ghostOptions.length > 0
-                        ? {
-                              key: 'Ghost Options',
-                              value: '\n' + ghostOptions.map((c) => `\t\t${c[0]} = ${c[1]}`).join('\n'),
-                          }
-                        : null,
-                    gdalMetadata
-                        ? {
-                              key: 'Metadata',
-                              value: '\n' + gdalMetadata.map((c) => `\t\t${c}`).join('\n'),
-                          }
-                        : null,
-                ],
-            },
-        ];
-
-        if (this.tags?.value || this.tagsAll?.value) {
-            for (const img of tif.images) {
-                const tiffTags = [...img.tags.keys()];
-                result.push({
-                    title: `Image: ${img.id} - Tiff tags`,
-                    keys: tiffTags.map((tagId) => formatTag(tagId, TiffTag[tagId], img.value(tagId))),
-                });
-                await img.loadGeoTiffTags();
-                if (img.tagsGeo) {
-                    const tiffTagsGeo = [...img.tagsGeo.keys()];
-                    result.push({
-                        title: `Image: ${img.id} - Geo Tiff tags`,
-                        keys: tiffTagsGeo.map((tagId) => formatTag(tagId, TiffTagGeo[tagId], img.valueGeo(tagId))),
-                    });
-                }
-                if (!this.tagsAll?.value) {
-                    break;
-                }
-            }
-        }
-
-        const msg = ActionUtil.formatResult(`${c.bold('COG File Info')} - ${c.bold(tif.source.uri)}`, result);
-        console.log(msg.join('\n'));
-    }
-
-    protected onDefineParameters(): void {
-        this.file = this.defineStringParameter({
-            argumentName: 'FILE',
-            parameterLongName: '--file',
-            parameterShortName: '-f',
-            description: 'cog file to access',
-            required: true,
-        });
-
-        this.tags = this.defineFlagParameter({
-            parameterLongName: '--tags',
-            parameterShortName: '-t',
-            description: 'Dump tiff tags',
-            required: false,
-        });
-
-        this.tagsAll = this.defineFlagParameter({
-            parameterLongName: '--tags-all',
-            parameterShortName: '-T',
-            description: 'Dump tiff tags for all images',
-            required: false,
-        });
-    }
-}

package/src/action.tile.ts

@@ -1,76 +0,0 @@
-import { TiffVersion } from '@cogeotiff/core';
-import { CommandLineAction, CommandLineStringParameter } from '@rushstack/ts-command-line';
-import c from 'ansi-colors';
-import { ChunkSourceBase } from '@chunkd/core';
-import { ActionUtil, CliResultMap } from './action.util.js';
-import { logger as Logger } from './cli.log.js';
-import { toByteSizeString } from './util.bytes.js';
-import { writeTile } from './util.tile.js';
-
-export class ActionTile extends CommandLineAction {
-    private file: CommandLineStringParameter | null = null;
-    private xyz: CommandLineStringParameter | null = null;
-
-    public constructor() {
-        super({
-            actionName: 'tile',
-            summary: 'Fetch a specific tile from a COG',
-            documentation: '',
-        });
-    }
-
-    async onExecute(): Promise<void> {
-        const logger = Logger.child({ action: 'tile' });
-
-        // abstract
-        const { tif } = await ActionUtil.getCogSource(this.file);
-        if (this.xyz == null || this.xyz.value == null) {
-            throw new Error('XYZ was not defined');
-        }
-
-        const [x, y, z] = this.xyz.value.split(',').map((c) => parseInt(c));
-        if (isNaN(x) || isNaN(y) || isNaN(z)) {
-            throw new Error('Invalid XYZ, format: "X,Y,Z"');
-        }
-
-        await writeTile(tif, x, y, z, '.', logger);
-        const source = tif.source as ChunkSourceBase;
-        const chunkIds = [...(source.chunks as Map<unknown, unknown>).values()];
-
-        const result: CliResultMap[] = [
-            {
-                keys: [
-                    { key: 'Tiff type', value: `${TiffVersion[tif.version]} (v${String(tif.version)})` },
-                    { key: 'Chunk size', value: toByteSizeString(tif.source.chunkSize) },
-                    {
-                        key: 'Bytes read',
-                        value: `${toByteSizeString(chunkIds.length * tif.source.chunkSize)} (${chunkIds.length} Chunk${
-                            chunkIds.length === 1 ? '' : 's'
-                        })`,
-                    },
-                ],
-            },
-        ];
-
-        const msg = ActionUtil.formatResult(`${c.bold('COG File Info')} - ${c.bold(tif.source.uri)}`, result);
-        console.log(msg.join('\n'));
-    }
-
-    protected onDefineParameters(): void {
-        // abstract
-        this.file = this.defineStringParameter({
-            argumentName: 'FILE',
-            parameterLongName: '--file',
-            parameterShortName: '-f',
-            description: 'cog file to access',
-            required: true,
-        });
-
-        this.xyz = this.defineStringParameter({
-            argumentName: 'XYZ',
-            parameterLongName: '--xyz',
-            description: '"X,Y,Z" of the tile to fetch',
-            required: true,
-        });
-    }
-}

package/src/cli.cog.info.ts

@@ -1,45 +0,0 @@
-import { CommandLineFlagParameter, CommandLineParser } from '@rushstack/ts-command-line';
-import { ActionDumpTile } from './action.dump.tile.js';
-import { ActionCogInfo } from './action.info.js';
-import { ActionTile } from './action.tile.js';
-import { logger } from './cli.log.js';
-
-export class CogInfoCommandLine extends CommandLineParser {
-    verbose?: CommandLineFlagParameter;
-    extraVerbose?: CommandLineFlagParameter;
-
-    constructor() {
-        super({
-            toolFilename: 'coginfo',
-            toolDescription: 'Cloud optimized geotiff utilities',
-        });
-
-        this.addAction(new ActionDumpTile());
-        this.addAction(new ActionCogInfo());
-        this.addAction(new ActionTile());
-    }
-
-    protected onExecute(): Promise<void> {
-        if (this.verbose?.value) {
-            logger.level = 'info';
-        } else if (this.extraVerbose?.value) {
-            logger.level = 'trace';
-        } else {
-            logger.level = 'warn';
-        }
-
-        return super.onExecute();
-    }
-    protected onDefineParameters(): void {
-        this.verbose = this.defineFlagParameter({
-            parameterLongName: '--verbose',
-            parameterShortName: '-v',
-            description: 'Show extra logging detail',
-        });
-        this.extraVerbose = this.defineFlagParameter({
-            parameterLongName: '--vv',
-            parameterShortName: '-V',
-            description: 'Show extra extra logging detail',
-        });
-    }
-}

package/src/cli.log.ts

@@ -1,4 +0,0 @@
-import pino from 'pino';
-import { PrettyTransform } from 'pretty-json-log';
-
-export const logger = process.stdout.isTTY ? pino(PrettyTransform.stream()) : pino();