@seasketch/geoprocessing/dist/src/types/datasource.js

Geoprocessing and reporting framework for SeaSketch 2.0

import { z } from "zod";
import { bboxSchema } from "./geojson.js";
// Schema and types for representing datasources used in calculating metrics
const GEO_TYPES = ["vector", "raster"];
export const geoTypesSchema = z.enum(GEO_TYPES);
const SUPPORTED_FORMATS = ["fgb", "json", "tif", "subdivided"];
export const supportedFormatsSchema = z.enum(SUPPORTED_FORMATS);
/** Data variable measurement type */
const MEASUREMENT_TYPES = [
    // "quantitative-discrete-integer",
    // "quantitative-continuous-ratio",
    // "categorical-binary",
    // "categorical-nominal",
    // "categorical-ordinal",
    "quantitative",
    "categorical",
];
export const measurementTypesSchema = z.enum(MEASUREMENT_TYPES);
/** Unused - Data variable recording precision */
const MEASUREMENT_SCALES = ["nominal", "ordinal", "interval", "ratio"];
export const measurementScalesSchema = z.enum(MEASUREMENT_SCALES);
export const statsSchema = z.object({
    count: z.number().nullable().optional(),
    sum: z.number().nullable().optional(),
    area: z.number().nullable().optional(),
});
/** Pre-calculated stats by key by class */
export const classStatsSchema = z.record(statsSchema);
export const baseDatasourceSchema = z.object({
    /** Unique id of datasource in project */
    datasourceId: z.string(),
    /** basic geospatial type */
    geo_type: geoTypesSchema,
    /** Available formats */
    formats: z.array(supportedFormatsSchema),
    /** Optional, defines whether or not precalc should be run for this datasource */
    precalc: z.boolean(),
    metadata: z
        .object({
        /** Human-readable name of datasource */
        name: z.string(),
        /** Description of datasource */
        description: z.string().optional(),
        /** Publisher-provided version number or ISO 8601 date */
        version: z.string(),
        /** Publisher name */
        publisher: z.string(),
        /** ISO 8601 publish date */
        publishDate: z.string(),
        /** Public URL to access published data */
        publishLink: z.string(),
    })
        .optional(),
});
/** Properties for vector datasource */
export const vectorDatasourceSchema = baseDatasourceSchema.merge(z.object({
    /** Optional, name of property containing unique ID value for each vector feature */
    idProperty: z.string().optional(),
    /** Optional, name of property containing name for each vector feature */
    nameProperty: z.string().optional(),
    /** Optional, constrain datasource features by property having one or more specific values */
    propertyFilter: z
        .object({
        property: z.string(),
        values: z.array(z.string().or(z.number())),
    })
        .optional(),
    /** Optional, constrain datasource to smaller bbox */
    bboxFilter: bboxSchema.optional(),
    /** Import - Name of layer within vector datasource to extract */
    layerName: z.string().optional(),
    /** properties whose values define classes of data. */
    classKeys: z.array(z.string()),
}));
/** Properties for raster datasource */
export const rasterDatasourceSchema = baseDatasourceSchema.merge(z.object({
    /** Type of measurements that the raster values represent */
    measurementType: measurementTypesSchema,
    /** Import - band within raster datasource to extract */
    band: z.number(),
    /** Nodata value */
    noDataValue: z.number().optional(),
}));
/** Properties for external datasource */
export const externalDatasourceSchema = z.object({
    /** Url if external datasource */
    url: z.string(),
});
/** Properties for importing an internal datasource */
export const internalImportSchema = z.object({
    /** Import - Path to source data, with filename */
    src: z.string(),
});
/** Timestamp properties to ease syncing with local/published datasource files */
export const internalDatasourceSchema = z.object({
    /** Datasource creation timestamp  */
    created: z.string(),
    /** Datasource updated timestamp */
    lastUpdated: z.string(),
});
/** Properties for import of internal vector datasources */
export const internalVectorImportSchema = internalImportSchema.merge(z.object({
    /** Import - What to keep in final dataset. Vector - properties, all else removed   */
    propertiesToKeep: z.array(z.string()),
    /** Import - Whether to explode multi-geometries into single e.g. MultiPolygon to Polygon. Defaults to true */
    explodeMulti: z.boolean(),
}));
export const internalVectorDatasourceSchema = vectorDatasourceSchema
    .merge(internalDatasourceSchema)
    .merge(internalVectorImportSchema);
export const externalVectorDatasourceSchema = vectorDatasourceSchema.and(externalDatasourceSchema);
export const internalRasterDatasourceSchema = rasterDatasourceSchema
    .merge(internalDatasourceSchema)
    .merge(internalImportSchema);
export const externalRasterDatasourceSchema = rasterDatasourceSchema.and(externalDatasourceSchema);
export const datasourceSchema = internalVectorDatasourceSchema
    .or(externalVectorDatasourceSchema)
    .or(internalRasterDatasourceSchema)
    .or(externalRasterDatasourceSchema);
export const datasourcesSchema = z.array(datasourceSchema);
//// IMPORT DATSOURCE ////
// SCHEMA //
export const importVectorDatasourceOptionsSchema = vectorDatasourceSchema.merge(internalVectorImportSchema);
export const importRasterDatasourceOptionsSchema = rasterDatasourceSchema.merge(internalImportSchema);
//# sourceMappingURL=datasource.js.map