@geoinsight/react-components 1.0.4 → 1.0.6

package/.yarn/unplugged/maplibre-gl-npm-2.4.0-9fa603cf50/node_modules/maplibre-gl/build/generate-style-code.ts

@@ -1,280 +0,0 @@
-'use strict';
-
-import * as fs from 'fs';
-
-import spec from '../src/style-spec/reference/v8.json' assert {type: 'json'};
-
-function camelCase(str: string): string {
-    return str.replace(/-(.)/g, (_, x) => {
-        return x.toUpperCase();
-    });
-}
-
-function pascalCase(str: string): string {
-    const almostCamelized = camelCase(str);
-    return almostCamelized[0].toUpperCase() + almostCamelized.slice(1);
-}
-
-function nativeType(property) {
-    switch (property.type) {
-        case 'boolean':
-            return 'boolean';
-        case 'number':
-            return 'number';
-        case 'string':
-            return 'string';
-        case 'enum':
-            return Object.keys(property.values).map(v => JSON.stringify(v)).join(' | ');
-        case 'color':
-            return 'Color';
-        case 'padding':
-            return 'Padding';
-        case 'formatted':
-            return 'Formatted';
-        case 'resolvedImage':
-            return 'ResolvedImage';
-        case 'array':
-            if (property.length) {
-                return `[${new Array(property.length).fill(nativeType({type: property.value})).join(', ')}]`;
-            } else {
-                return `Array<${nativeType({type: property.value, values: property.values})}>`;
-            }
-        default: throw new Error(`unknown type for ${property.name}`);
-    }
-}
-
-function possiblyEvaluatedType(property)  {
-    const propType = nativeType(property);
-
-    switch (property['property-type']) {
-        case 'color-ramp':
-            return 'ColorRampProperty';
-        case 'cross-faded':
-            return `CrossFaded<${propType}>`;
-        case 'cross-faded-data-driven':
-            return `PossiblyEvaluatedPropertyValue<CrossFaded<${propType}>>`;
-        case 'data-driven':
-            return `PossiblyEvaluatedPropertyValue<${propType}>`;
-    }
-
-    return propType;
-}
-
-function propertyType(property) {
-    switch (property['property-type']) {
-        case 'data-driven':
-            return `DataDrivenProperty<${nativeType(property)}>`;
-        case 'cross-faded':
-            return `CrossFadedProperty<${nativeType(property)}>`;
-        case 'cross-faded-data-driven':
-            return `CrossFadedDataDrivenProperty<${nativeType(property)}>`;
-        case 'color-ramp':
-            return 'ColorRampProperty';
-        case 'data-constant':
-        case 'constant':
-            return `DataConstantProperty<${nativeType(property)}>`;
-        default:
-            throw new Error(`unknown property-type "${property['property-type']}" for ${property.name}`);
-    }
-}
-
-function runtimeType(property) {
-    switch (property.type) {
-        case 'boolean':
-            return 'BooleanType';
-        case 'number':
-            return 'NumberType';
-        case 'string':
-        case 'enum':
-            return 'StringType';
-        case 'color':
-            return 'ColorType';
-        case 'padding':
-            return 'PaddingType';
-        case 'formatted':
-            return 'FormattedType';
-        case 'Image':
-            return 'ImageType';
-        case 'array':
-            if (property.length) {
-                return `array(${runtimeType({type: property.value})}, ${property.length})`;
-            } else {
-                return `array(${runtimeType({type: property.value})})`;
-            }
-        default: throw new Error(`unknown type for ${property.name}`);
-    }
-}
-
-function overrides(property) {
-    return `{ runtimeType: ${runtimeType(property)}, getOverride: (o) => o.${camelCase(property.name)}, hasOverride: (o) => !!o.${camelCase(property.name)} }`;
-}
-
-function propertyValue(property, type) {
-    const propertyAsSpec = `styleSpec["${type}_${property.layerType}"]["${property.name}"] as any as StylePropertySpecification`;
-
-    switch (property['property-type']) {
-        case 'data-driven':
-            if (property.overridable) {
-                return `new DataDrivenProperty(${propertyAsSpec}, ${overrides(property)})`;
-            } else {
-                return `new DataDrivenProperty(${propertyAsSpec})`;
-            }
-        case 'cross-faded':
-            return `new CrossFadedProperty(${propertyAsSpec})`;
-        case 'cross-faded-data-driven':
-            return `new CrossFadedDataDrivenProperty(${propertyAsSpec})`;
-        case 'color-ramp':
-            return `new ColorRampProperty(${propertyAsSpec})`;
-        case 'data-constant':
-        case 'constant':
-            return `new DataConstantProperty(${propertyAsSpec})`;
-        default:
-            throw new Error(`unknown property-type "${property['property-type']}" for ${property.name}`);
-    }
-}
-
-const layers = Object.keys(spec.layer.type.values).map((type) => {
-    const layoutProperties = Object.keys(spec[`layout_${type}`]).reduce((memo, name) => {
-        if (name !== 'visibility') {
-            spec[`layout_${type}`][name].name = name;
-            spec[`layout_${type}`][name].layerType = type;
-            memo.push(spec[`layout_${type}`][name]);
-        }
-        return memo;
-    }, []);
-
-    const paintProperties = Object.keys(spec[`paint_${type}`]).reduce((memo, name) => {
-        spec[`paint_${type}`][name].name = name;
-        spec[`paint_${type}`][name].layerType = type;
-        memo.push(spec[`paint_${type}`][name]);
-        return memo;
-    }, []);
-
-    return {type, layoutProperties, paintProperties};
-});
-
-function emitlayerProperties(locals) {
-    const output = [];
-    const layerType = pascalCase(locals.type);
-    const {
-        layoutProperties,
-        paintProperties
-    } = locals;
-
-    output.push(
-        `// This file is generated. Edit build/generate-style-code.ts, then run 'npm run codegen'.
-/* eslint-disable */
-
-import styleSpec from '../../style-spec/reference/latest';
-
-import {
-    Properties,
-    DataConstantProperty,
-    DataDrivenProperty,
-    CrossFadedDataDrivenProperty,
-    CrossFadedProperty,
-    ColorRampProperty,
-    PossiblyEvaluatedPropertyValue,
-    CrossFaded
-} from '../properties';
-
-import type Color from '../../style-spec/util/color';
-import type Padding from '../../style-spec/util/padding';
-
-import type Formatted from '../../style-spec/expression/types/formatted';
-
-import type ResolvedImage from '../../style-spec/expression/types/resolved_image';
-import {StylePropertySpecification} from '../../style-spec/style-spec';
-`);
-
-    const overridables = paintProperties.filter(p => p.overridable);
-    if (overridables.length) {
-        output.push(
-            `import {
-    ${overridables.reduce((imports, prop) => { imports.push(runtimeType(prop)); return imports; }, []).join(',\n    ')}
-} from '../../style-spec/expression/types';
-`);
-    }
-
-    if (layoutProperties.length) {
-        output.push(
-            `export type ${layerType}LayoutProps = {`);
-
-        for (const property of layoutProperties) {
-            output.push(
-                `    "${property.name}": ${propertyType(property)},`);
-        }
-
-        output.push(
-            `};
-
-export type ${layerType}LayoutPropsPossiblyEvaluated = {`);
-
-        for (const property of layoutProperties) {
-            output.push(
-                `    "${property.name}": ${possiblyEvaluatedType(property)},`);
-        }
-
-        output.push(
-            `};
-
-const layout: Properties<${layerType}LayoutProps> = new Properties({`);
-
-        for (const property of layoutProperties) {
-            output.push(
-                `    "${property.name}": ${propertyValue(property, 'layout')},`);
-        }
-
-        output.push(
-            '});');
-    }
-
-    if (paintProperties.length) {
-        output.push(
-            `
-export type ${layerType}PaintProps = {`);
-
-        for (const property of paintProperties) {
-            output.push(
-                `    "${property.name}": ${propertyType(property)},`);
-        }
-
-        output.push(
-            `};
-
-export type ${layerType}PaintPropsPossiblyEvaluated = {`);
-
-        for (const property of paintProperties) {
-            output.push(
-                `    "${property.name}": ${possiblyEvaluatedType(property)},`);
-        }
-
-        output.push(
-            '};');
-    } else {
-        output.push(
-            `export type ${layerType}PaintProps = {};`);
-    }
-
-    output.push(
-        `
-const paint: Properties<${layerType}PaintProps> = new Properties({`);
-
-    for (const property of paintProperties) {
-        output.push(
-            `    "${property.name}": ${propertyValue(property, 'paint')},`);
-    }
-
-    output.push(
-        `});
-
-export default ({ paint${layoutProperties.length ? ', layout' : ''} } as {
-    paint: Properties<${layerType}PaintProps>${layoutProperties.length ? `,\n    layout: Properties<${layerType}LayoutProps>` : ''}
-});`);
-
-    return output.join('\n');
-}
-
-for (const layer of layers) {
-    fs.writeFileSync(`src/style/style_layer/${layer.type.replace('-', '_')}_style_layer_properties.g.ts`, emitlayerProperties(layer));
-}

package/.yarn/unplugged/maplibre-gl-npm-2.4.0-9fa603cf50/node_modules/maplibre-gl/build/generate-style-spec.ts

@@ -1,323 +0,0 @@
-import * as fs from 'fs';
-import * as properties from '../src/style-spec/util/properties';
-
-import spec from '../src/style-spec/reference/v8.json' assert {type: 'json'};
-
-function unionType(values) {
-    if (Array.isArray(values)) {
-        return values.map(v => JSON.stringify(v)).join(' | ');
-    } else {
-        return Object.keys(values).map(v => JSON.stringify(v)).join(' | ');
-    }
-}
-
-function propertyType(property) {
-    if (typeof property.type === 'function') {
-        return property.type();
-    }
-
-    const baseType = (() => {
-        switch (property.type) {
-            case 'string':
-            case 'number':
-            case 'boolean':
-                return property.type;
-            case 'enum':
-                return unionType(property.values);
-            case 'array': {
-                const elementType = propertyType(typeof property.value === 'string' ? {type: property.value, values: property.values} : property.value);
-                if (property.length) {
-                    return `[${Array(property.length).fill(elementType).join(', ')}]`;
-                } else {
-                    return `Array<${elementType}>`;
-                }
-            }
-            case 'light':
-                return 'LightSpecification';
-            case 'sources':
-                return '{[_: string]: SourceSpecification}';
-            case '*':
-                return 'unknown';
-            default:
-                return `${property.type.slice(0, 1).toUpperCase()}${property.type.slice(1)}Specification`;
-        }
-    })();
-
-    if (properties.supportsPropertyExpression(property)) {
-        return `DataDrivenPropertyValueSpecification<${baseType}>`;
-    } else if (properties.supportsZoomExpression(property)) {
-        return `PropertyValueSpecification<${baseType}>`;
-    } else if (property.expression) {
-        return 'ExpressionSpecification';
-    } else {
-        return baseType;
-    }
-}
-
-function propertyDeclaration(key, property) {
-    return `"${key}"${property.required ? '' : '?'}: ${propertyType(property)}`;
-}
-
-function objectDeclaration(key, properties) {
-    return `export type ${key} = ${objectType(properties, '')};`;
-}
-
-function objectType(properties, indent) {
-    return `{
-${Object.keys(properties)
-        .filter(k => k !== '*')
-        .map(k => `    ${indent}${propertyDeclaration(k, properties[k])}`)
-        .join(',\n')}
-${indent}}`;
-}
-
-function sourceTypeName(key) {
-    return key.replace(/source_(.)(.*)/, (_, _1, _2) => `${_1.toUpperCase()}${_2}SourceSpecification`)
-        .replace(/_dem/, 'DEM')
-        .replace(/Geojson/, 'GeoJSON');
-}
-
-function layerTypeName(key) {
-    return key.split('-').map(k => k.replace(/(.)(.*)/, (_, _1, _2) => `${_1.toUpperCase()}${_2}`)).concat('LayerSpecification').join('');
-}
-
-function layerType(key) {
-    const layer = spec.layer as any;
-
-    layer.type = {
-        type: 'enum',
-        values: [key],
-        required: true
-    };
-
-    delete layer.ref;
-    delete layer['paint.*'];
-
-    layer.paint.type = () => {
-        return objectType(spec[`paint_${key}`], '    ');
-    };
-
-    layer.layout.type = () => {
-        return objectType(spec[`layout_${key}`], '    ');
-    };
-
-    if (key === 'background') {
-        delete layer.source;
-        delete layer['source-layer'];
-        delete layer.filter;
-    } else {
-        layer.source.required = true;
-    }
-
-    return objectDeclaration(layerTypeName(key), layer);
-}
-
-const layerTypes = Object.keys(spec.layer.type.values);
-
-fs.writeFileSync('src/style-spec/types.g.ts',
-    `// Generated code; do not edit. Edit build/generate-style-spec.ts instead.
-/* eslint-disable */
-
-export type ColorSpecification = string;
-
-export type PaddingSpecification = number | number[];
-
-export type FormattedSpecification = string;
-
-export type ResolvedImageSpecification = string;
-
-export type PromoteIdSpecification = {[_: string]: string} | string;
-
-export type ExpressionInputType = string | number | boolean;
-
-export type CollatorExpressionSpecification = 
-    ['collator', {
-        'case-sensitive'?: boolean | ExpressionSpecification, 
-        'diacritic-sensitive'?: boolean | ExpressionSpecification, 
-        locale?: string | ExpressionSpecification}
-    ]; // collator
-
-export type InterpolationSpecification =
-    | ['linear'] 
-    | ['exponential', number | ExpressionSpecification] 
-    | ['cubic-bezier', number | ExpressionSpecification, number | ExpressionSpecification, number | ExpressionSpecification, number | ExpressionSpecification]
-
-export type ExpressionSpecification = 
-    // types
-    | ['array', unknown | ExpressionSpecification] // array
-    | ['array', ExpressionInputType | ExpressionSpecification, unknown | ExpressionSpecification] // array
-    | ['array', ExpressionInputType | ExpressionSpecification, number | ExpressionSpecification, unknown | ExpressionSpecification] // array
-    | ['boolean', ...(unknown | ExpressionSpecification)[], unknown | ExpressionSpecification] // boolean
-    | CollatorExpressionSpecification
-    | ['format', ...(string | ['image', ExpressionSpecification] | ExpressionSpecification | {'font-scale'?: number | ExpressionSpecification, 'text-font'?: string[] | ExpressionSpecification, 'text-color': ColorSpecification | ExpressionSpecification})[]] // string
-    | ['image', unknown | ExpressionSpecification] // image
-    | ['literal', unknown]
-    | ['number', unknown | ExpressionSpecification, ...(unknown | ExpressionSpecification)[]] // number
-    | ['number-format', number | ExpressionSpecification, {'locale'?: string | ExpressionSpecification, 'currency'?: string | ExpressionSpecification, 'min-fraction-digits'?: number | ExpressionSpecification, 'max-fraction-digits'?: number | ExpressionSpecification}] // string
-    | ['object', unknown | ExpressionSpecification, ...(unknown | ExpressionSpecification)[]] // object
-    | ['string', unknown | ExpressionSpecification, ...(unknown | ExpressionSpecification)[]] // string
-    | ['to-boolean', unknown | ExpressionSpecification] // boolean
-    | ['to-color', unknown | ExpressionSpecification, ...(unknown | ExpressionSpecification)[]] // color
-    | ['to-number', unknown | ExpressionSpecification, ...(unknown | ExpressionSpecification)[]] // number
-    | ['to-string', unknown | ExpressionSpecification] // string
-    // feature data
-    | ['accumulated']
-    | ['feature-state', string]
-    | ['geometry-type'] // string
-    | ['id']
-    | ['line-progress'] // number
-    | ['properties'] // object
-    // lookup
-    | ['at', number | ExpressionSpecification, ExpressionSpecification]
-    | ['get', string | ExpressionSpecification, (Record<string, unknown> | ExpressionSpecification)?]
-    | ['has', string | ExpressionSpecification, (Record<string, unknown> | ExpressionSpecification)?]
-    | ['in', ExpressionInputType | ExpressionSpecification, ExpressionInputType | ExpressionSpecification]
-    | ['index-of', ExpressionInputType | ExpressionSpecification, ExpressionInputType | ExpressionSpecification] // number
-    | ['length', string | ExpressionSpecification]
-    | ['slice', string | ExpressionSpecification, number | ExpressionSpecification]
-    // Decision
-    | ['!', boolean | ExpressionSpecification] // boolean
-    | ['!=', ExpressionInputType | ExpressionSpecification, ExpressionInputType | ExpressionSpecification, CollatorExpressionSpecification?] // boolean
-    | ['<', ExpressionInputType | ExpressionSpecification, ExpressionInputType | ExpressionSpecification, CollatorExpressionSpecification?] // boolean
-    | ['<=', ExpressionInputType | ExpressionSpecification, ExpressionInputType | ExpressionSpecification, CollatorExpressionSpecification?] // boolean
-    | ['==', ExpressionInputType | ExpressionSpecification, ExpressionInputType | ExpressionSpecification, CollatorExpressionSpecification?] // boolean
-    | ['>', ExpressionInputType | ExpressionSpecification, ExpressionInputType | ExpressionSpecification, CollatorExpressionSpecification?] // boolean
-    | ['>=', ExpressionInputType | ExpressionSpecification, ExpressionInputType | ExpressionSpecification, CollatorExpressionSpecification?] // boolean
-    | ['all', ...(boolean | ExpressionSpecification)[]] // boolean
-    | ['any', ...(boolean | ExpressionSpecification)[]] // boolean
-    | ['case', boolean | ExpressionSpecification, ExpressionInputType | ExpressionSpecification, 
-        ...(boolean | ExpressionInputType | ExpressionSpecification)[], ExpressionInputType | ExpressionSpecification]
-    | ['coalesce', ...(ExpressionInputType | ExpressionSpecification)[]] // at least two inputs required
-    | ['match', ExpressionInputType | ExpressionSpecification, 
-        ExpressionInputType | ExpressionInputType[], ExpressionInputType | ExpressionSpecification, 
-        ...(ExpressionInputType | ExpressionInputType[] | ExpressionSpecification)[], // repeated as above
-        ExpressionInputType]
-    | ['within', unknown | ExpressionSpecification]
-    // Ramps, scales, curves
-    | ['interpolate', InterpolationSpecification, number | ExpressionSpecification, 
-        ...(number | number[] | ColorSpecification)[]] // alternating number and number | number[] | ColorSpecification
-    | ['interpolate-hcl', InterpolationSpecification, number | ExpressionSpecification, 
-        ...(number | ColorSpecification)[]] // alternating number and ColorSpecificaton
-    | ['interpolate-lab', InterpolationSpecification, number | ExpressionSpecification, 
-        ...(number | ColorSpecification)[]] // alternating number and ColorSpecification
-    | ['step', number | ExpressionSpecification, ExpressionInputType | ExpressionSpecification,
-        ...(number | ExpressionInputType | ExpressionSpecification)[]] // alternating number and ExpressionInputType | ExpressionSpecification
-    // Variable binding
-    | ['let', string, ExpressionInputType | ExpressionSpecification, ...(string | ExpressionInputType | ExpressionSpecification)[]]
-    | ['var', string]
-    // String
-    | ['concat', ...(ExpressionInputType | ExpressionSpecification)[]] // at least two inputs required -> string
-    | ['downcase', string | ExpressionSpecification] // string
-    | ['is-supported-script', string | ExpressionSpecification] // boolean
-    | ['resolved-locale', CollatorExpressionSpecification] // string
-    | ['upcase', string | ExpressionSpecification] // string
-    // Color
-    | ['rgb', number | ExpressionSpecification, number | ExpressionSpecification, number | ExpressionSpecification] // color
-    | ['rgba', number | ExpressionSpecification, number | ExpressionSpecification, number | ExpressionSpecification, number | ExpressionSpecification]
-    | ['to-rgba', ColorSpecification | ExpressionSpecification]
-    // Math
-    | ['-', number | ExpressionSpecification, (number | ExpressionSpecification)?] // number
-    | ['*', number | ExpressionSpecification, number | ExpressionSpecification, ...(number | ExpressionSpecification)[]] // number
-    | ['/', number | ExpressionSpecification, number | ExpressionSpecification] // number
-    | ['%', number | ExpressionSpecification, number | ExpressionSpecification] // number
-    | ['^', number | ExpressionSpecification, number | ExpressionSpecification] // number
-    | ['+', ...(number | ExpressionSpecification)[]] // at least two inputs required -> number
-    | ['abs', number | ExpressionSpecification] // number
-    | ['acos', number | ExpressionSpecification] // number
-    | ['asin', number | ExpressionSpecification] // number
-    | ['atan', number | ExpressionSpecification] // number
-    | ['ceil', number | ExpressionSpecification] // number
-    | ['cos', number | ExpressionSpecification] // number
-    | ['distance', Record<string, unknown> | ExpressionSpecification] // number
-    | ['ExpressionSpecification'] // number
-    | ['floor', number | ExpressionSpecification] // number
-    | ['ln', number | ExpressionSpecification] // number
-    | ['ln2'] // number
-    | ['log10', number | ExpressionSpecification] // number
-    | ['log2', number | ExpressionSpecification] // number
-    | ['max', number | ExpressionSpecification, ...(number | ExpressionSpecification)[]] // number
-    | ['min', number | ExpressionSpecification, ...(number | ExpressionSpecification)[]] // number
-    | ['pi'] // number
-    | ['round', number | ExpressionSpecification] // number
-    | ['sin', number | ExpressionSpecification] // number
-    | ['sqrt', number | ExpressionSpecification] // number
-    | ['tan', number | ExpressionSpecification] // number
-    // Zoom
-    | ['zoom'] // number
-    // Heatmap
-    | ['heatmap-density'] // number
-
-export type ExpressionFilterSpecification = boolean | ExpressionSpecification
-
-export type LegacyFilterSpecification =
-    // Existential
-    | ['has', string]
-    | ['!has', string]
-    // Comparison
-    | ['==', string, string | number | boolean]
-    | ['!=', string, string | number | boolean]
-    | ['>', string, string | number | boolean]
-    | ['>=', string, string | number | boolean]
-    | ['<', string, string | number | boolean]
-    | ['<=', string, string | number | boolean]
-    // Set membership
-    | ['in', string, ...(string | number | boolean)[]]
-    | ['!in', string, ...(string | number | boolean)[]]
-    // Combining
-    | ['all', ...LegacyFilterSpecification[]]
-    | ['any', ...LegacyFilterSpecification[]]
-    | ['none', ...LegacyFilterSpecification[]]
-
-export type FilterSpecification = ExpressionFilterSpecification | LegacyFilterSpecification
-
-export type TransitionSpecification = {
-    duration?: number,
-    delay?: number
-};
-
-// Note: doesn't capture interpolatable vs. non-interpolatable types.
-
-export type CameraFunctionSpecification<T> =
-      { type: 'exponential', stops: Array<[number, T]> }
-    | { type: 'interval',    stops: Array<[number, T]> };
-
-export type SourceFunctionSpecification<T> =
-      { type: 'exponential', stops: Array<[number, T]>, property: string, default?: T }
-    | { type: 'interval',    stops: Array<[number, T]>, property: string, default?: T }
-    | { type: 'categorical', stops: Array<[string | number | boolean, T]>, property: string, default?: T }
-    | { type: 'identity', property: string, default?: T };
-
-export type CompositeFunctionSpecification<T> =
-      { type: 'exponential', stops: Array<[{zoom: number, value: number}, T]>, property: string, default?: T }
-    | { type: 'interval',    stops: Array<[{zoom: number, value: number}, T]>, property: string, default?: T }
-    | { type: 'categorical', stops: Array<[{zoom: number, value: string | number | boolean}, T]>, property: string, default?: T };
-
-export type PropertyValueSpecification<T> =
-      T
-    | CameraFunctionSpecification<T>
-    | ExpressionSpecification;
-
-export type DataDrivenPropertyValueSpecification<T> =
-      T
-    | CameraFunctionSpecification<T>
-    | SourceFunctionSpecification<T>
-    | CompositeFunctionSpecification<T>
-    | ExpressionSpecification;
-
-${objectDeclaration('StyleSpecification', spec.$root)}
-
-${objectDeclaration('LightSpecification', spec.light)}
-
-${objectDeclaration('TerrainSpecification', spec.terrain)}
-
-${spec.source.map(key => objectDeclaration(sourceTypeName(key), spec[key])).join('\n\n')}
-
-export type SourceSpecification =
-${spec.source.map(key => `    | ${sourceTypeName(key)}`).join('\n')}
-
-${layerTypes.map(key => layerType(key)).join('\n\n')}
-
-export type LayerSpecification =
-${layerTypes.map(key => `    | ${layerTypeName(key)}`).join('\n')};
-
-`);

package/.yarn/unplugged/maplibre-gl-npm-2.4.0-9fa603cf50/node_modules/maplibre-gl/build/generate-typings.ts

@@ -1,26 +0,0 @@
-
-import fs from 'fs';
-import childProcess from 'child_process';
-
-if (!fs.existsSync('dist')) {
-    fs.mkdirSync('dist');
-}
-
-console.log('Starting bundling types');
-let outputFile = './dist/maplibre-gl.d.ts';
-childProcess.execSync(`dts-bundle-generator --umd-module-name=maplibregl -o ${outputFile} ./src/index.ts`);
-let types = fs.readFileSync(outputFile, 'utf8');
-// Classes are not exported but should be since this is exported as UMD - fixing...
-types = types.replace(/declare class/g, 'export declare class');
-fs.writeFileSync(outputFile, types);
-
-console.log('Finifhed bundling types for maplibre-gl starting style-spec');
-
-const outputPath = './dist/style-spec';
-if (!fs.existsSync(outputPath)) {
-    fs.mkdirSync(outputPath);
-}
-outputFile = `${outputPath}/index.d.ts`;
-childProcess.execSync(`dts-bundle-generator -o ${outputFile} ./src/style-spec/style-spec.ts`);
-
-console.log('Finished bundling types');

package/.yarn/unplugged/maplibre-gl-npm-2.4.0-9fa603cf50/node_modules/maplibre-gl/build/readme.md

@@ -1,52 +0,0 @@
-# Build Scripts
-This folder holds common build scripts accessed via the various `npm run` commands.
-Codegen is executed when calling `npm install` in order to generate all artifacts needed for the build to pass
-## Bundeling all the code
-
-The bundeling process can be split into several steps:
-
-`npm run build-css`
-This command will compile the css code and create the css file.
-
-`npm run build-prod` and `npm run build-dev`
-These commands will use rollup to bundle the code. This is where the magic happens and uses some files in this folder.
-
-`banner.ts` is used to create a banner at the beginning of the output file
-
-`rollup_plugins.ts` is used to define common plugins for rollup configurations
-
-`rollup_plugin_minify_style_spec.ts` is used to specify the plugin used in style spec bundeling
-
-In the `rollup` folder there are some files that are used as linking files as they link to other files for rollup to pick when bundling.
-
-Rollup is generating 3 files throughout the process of bundling: 
-
-`index.ts` a file containing all the code that will run in the main thread. 
-
-`shared.ts` a file containing all the code shared between the main and worker code.
-
-`worker.ts` a file containing all the code the will run in the worker threads.
-
-These 3 files are then referenced and used by the `bundle_prelude.js` file. It allows loading the web wroker code automatically in web workers without any extra effort from someone who would like to use the library, i.e. it simply works.
-
-### check-bundle-size.js
-This file is used by CI to make sure the bundle size is kept constant
-
-<hr>
-
-### `npm run codegen`
-The `codegen` command runs the following three scripts, to update the corresponding code files based on the `v8.json` style source, and other data files. Contributers should run this command manually when the underlying style data is modified. The generated code files are then commited to the repo.
-#### generate-struct-arrays.ts		
-Generates `data/array_types.ts`, which consists of:
- - `StructArrayLayout_*` subclasses, one for each underlying memory layout
- - Named exports mapping each conceptual array type (e.g., `CircleLayoutArray`) to its corresponding `StructArrayLayout` class
- - Specific named `StructArray` subclasses, when type-specific struct accessors are needed (e.g., `CollisionBoxArray`)
-#### generate-style-code.ts			
-Generates the various `style/style_layer/[layer type]_style_layer_properties.ts` code files based on the content of `v8.json`. These files provide the type signatures for the paint and layout properties for each type of style layer.
-#### generate-style-spec.ts			
-Generates `style-spec/types.ts` based on the content of `v8.json`. This provides the type signatures for a style specification (sources, layers, etc.).
-<hr>
-
-### Generate Release Nodes
-
-`release-notes.js` Used to generate release notes when releasing a new version