@aprestmo/norway-geodata 0.1.0

package/dist/index.js

@@ -0,0 +1,433 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVersion = getVersion;
+exports.getMunicipalities = getMunicipalities;
+exports.getMunicipalityById = getMunicipalityById;
+exports.getMunicipalitiesByName = getMunicipalitiesByName;
+exports.getCounties = getCounties;
+exports.getCountyById = getCountyById;
+exports.getCountyByName = getCountyByName;
+exports.getMunicipalitiesByCounty = getMunicipalitiesByCounty;
+exports.getMunicipalityByPostalCode = getMunicipalityByPostalCode;
+exports.getPostalCodesByMunicipality = getPostalCodesByMunicipality;
+exports.getAllPostalCodes = getAllPostalCodes;
+exports.getMunicipalitiesByPopulation = getMunicipalitiesByPopulation;
+exports.getMunicipalitiesByArea = getMunicipalitiesByArea;
+exports.getMunicipalitiesByLanguage = getMunicipalitiesByLanguage;
+exports.getMunicipalitiesFiltered = getMunicipalitiesFiltered;
+exports.getTotalPopulation = getTotalPopulation;
+exports.getTotalArea = getTotalArea;
+exports.getPopulationDensityStats = getPopulationDensityStats;
+exports.getMunicipalitiesByPopulationDensity = getMunicipalitiesByPopulationDensity;
+exports.getLargestMunicipalities = getLargestMunicipalities;
+exports.getSmallestMunicipalities = getSmallestMunicipalities;
+exports.getPostalCodes = getPostalCodes;
+exports.getPostalCodeByCode = getPostalCodeByCode;
+exports.getPostalCodesByPlace = getPostalCodesByPlace;
+exports.getPostalCodesByMunicipalityId = getPostalCodesByMunicipalityId;
+exports.getUniquePostalPlaces = getUniquePostalPlaces;
+exports.getPostalCodesInRange = getPostalCodesInRange;
+exports.getPostalCodesStats = getPostalCodesStats;
+exports.getPostalCodesSorted = getPostalCodesSorted;
+exports.isValidPostalCode = isValidPostalCode;
+exports.getPostalCodesByMunicipalityName = getPostalCodesByMunicipalityName;
+const kommuner_2025_json_1 = __importDefault(require("../data/kommuner-2025.json"));
+const fylker_2025_json_1 = __importDefault(require("../data/fylker-2025.json"));
+const postal_codes_2025_json_1 = __importDefault(require("../data/postal-codes-2025.json"));
+const package_json_1 = __importDefault(require("../package.json"));
+// Type-safe data imports
+const municipalities = kommuner_2025_json_1.default;
+const counties = fylker_2025_json_1.default;
+const postalCodes = postal_codes_2025_json_1.default;
+/**
+ * Get the library version following semantic versioning.
+ * @returns Version string (e.g., "1.0.0")
+ */
+function getVersion() {
+    return package_json_1.default.version;
+}
+/**
+ * Get all municipalities with metadata.
+ * @returns Array of all municipalities
+ */
+function getMunicipalities() {
+    return municipalities;
+}
+/**
+ * Get a municipality by municipality ID.
+ * @param id - 4-digit municipality ID (e.g., "0301" for Oslo)
+ * @returns Municipality object or undefined if not found
+ * @throws {TypeError} If id is not a string
+ */
+function getMunicipalityById(id) {
+    if (typeof id !== 'string') {
+        throw new TypeError('Municipality ID must be a string');
+    }
+    return municipalities.find(m => m.k_id === id);
+}
+/**
+ * Get municipalities by name (case-insensitive partial match by default).
+ * @param name - Municipality name or partial name to search for
+ * @param options - Search options
+ * @returns Array of matching municipalities
+ * @throws {TypeError} If name is not a string
+ */
+function getMunicipalitiesByName(name, options = {}) {
+    if (typeof name !== 'string') {
+        throw new TypeError('Municipality name must be a string');
+    }
+    const { includeAllNames = true, caseSensitive = false, exactMatch = false } = options;
+    const searchTerm = caseSensitive ? name : name.toLowerCase();
+    return municipalities.filter(m => {
+        const namesToSearch = includeAllNames
+            ? [m.k_name, m.k_name_no]
+            : [m.k_name];
+        return namesToSearch.some(municipalityName => {
+            const compareString = caseSensitive
+                ? municipalityName
+                : municipalityName.toLowerCase();
+            return exactMatch
+                ? compareString === searchTerm
+                : compareString.includes(searchTerm);
+        });
+    });
+}
+/**
+ * Get all counties (fylker) with metadata.
+ * @returns Array of all counties
+ */
+function getCounties() {
+    return counties;
+}
+/**
+ * Get a county by county ID.
+ * @param id - 2-digit county ID (e.g., "03" for Oslo)
+ * @returns County object or undefined if not found
+ * @throws {TypeError} If id is not a string
+ */
+function getCountyById(id) {
+    if (typeof id !== 'string') {
+        throw new TypeError('County ID must be a string');
+    }
+    return counties.find(f => f.f_id === id);
+}
+/**
+ * Get county by name (case-insensitive partial match).
+ * @param name - County name or partial name to search for
+ * @param exactMatch - Whether to match exactly (default: false)
+ * @returns County object or undefined if not found
+ * @throws {TypeError} If name is not a string
+ */
+function getCountyByName(name, exactMatch = false) {
+    if (typeof name !== 'string') {
+        throw new TypeError('County name must be a string');
+    }
+    const searchTerm = name.toLowerCase();
+    return counties.find(f => {
+        const countyName = f.f_name.toLowerCase();
+        return exactMatch ? countyName === searchTerm : countyName.includes(searchTerm);
+    });
+}
+/**
+ * Get all municipalities in a given county.
+ * @param countyId - 2-digit county ID (first two digits of municipality k_id)
+ * @returns Array of municipalities in the county
+ * @throws {TypeError} If countyId is not a string
+ */
+function getMunicipalitiesByCounty(countyId) {
+    if (typeof countyId !== 'string') {
+        throw new TypeError('County ID must be a string');
+    }
+    return municipalities.filter(m => m.k_id.startsWith(countyId));
+}
+/**
+ * Get municipality by postal code.
+ * @param postalCode - Postal code to search for
+ * @returns Municipality object or undefined if not found
+ * @throws {TypeError} If postal code is not a valid number
+ */
+function getMunicipalityByPostalCode(postalCode) {
+    const code = String(postalCode);
+    if (!code.match(/^\d{4}$/)) {
+        throw new TypeError('Postal code must be a valid 4-digit number');
+    }
+    return municipalities.find(m => m.k_postal_codes.some(pc => pc.postal_code === code));
+}
+/**
+ * Get all postal codes for a specific municipality.
+ * @param municipalityId - 4-digit municipality ID
+ * @returns Array of postal codes or undefined if municipality not found
+ */
+function getPostalCodesByMunicipality(municipalityId) {
+    const municipality = getMunicipalityById(municipalityId);
+    return municipality ? municipality.k_postal_codes.map(pc => pc.postal_code) : undefined;
+}
+/**
+ * Get all postal codes from all municipalities.
+ * @param includeDetails - If true, returns objects with postal code and place name. If false, returns only postal codes (default: false)
+ * @returns Array of postal codes or postal code objects
+ */
+function getAllPostalCodes(includeDetails = false) {
+    if (includeDetails) {
+        const allPostalCodes = [];
+        municipalities.forEach(municipality => {
+            municipality.k_postal_codes.forEach(pc => {
+                allPostalCodes.push({
+                    zip: pc.postal_code,
+                    place: pc.postal_place,
+                    municipalityId: municipality.k_id,
+                    municipalityName: municipality.k_name
+                });
+            });
+        });
+        return allPostalCodes.sort((a, b) => a.zip.localeCompare(b.zip));
+    }
+    else {
+        const allPostalCodes = new Set();
+        municipalities.forEach(municipality => {
+            municipality.k_postal_codes.forEach(pc => {
+                allPostalCodes.add(pc.postal_code);
+            });
+        });
+        return Array.from(allPostalCodes).sort();
+    }
+}
+/**
+ * Get municipalities sorted by population.
+ * @param ascending - Sort in ascending order if true (default: false for descending)
+ * @returns Array of municipalities sorted by population
+ */
+function getMunicipalitiesByPopulation(ascending = false) {
+    const sorted = [...municipalities].sort((a, b) => ascending ? a.k_population - b.k_population : b.k_population - a.k_population);
+    return sorted;
+}
+/**
+ * Get municipalities sorted by area.
+ * @param ascending - Sort in ascending order if true (default: false for descending)
+ * @returns Array of municipalities sorted by area
+ */
+function getMunicipalitiesByArea(ascending = false) {
+    const sorted = [...municipalities].sort((a, b) => ascending ? a.k_area - b.k_area : b.k_area - a.k_area);
+    return sorted;
+}
+/**
+ * Get municipalities by language status.
+ * @param language - Language status
+ * @returns Array of municipalities with the specified language status
+ * @throws {TypeError} If language is not a string
+ */
+function getMunicipalitiesByLanguage(language) {
+    if (typeof language !== 'string') {
+        throw new TypeError('Language must be a string');
+    }
+    return municipalities.filter(m => m.k_language === language);
+}
+/**
+ * Get municipalities with advanced filtering options.
+ * @param options - Filter options
+ * @returns Array of municipalities matching the filter criteria
+ */
+function getMunicipalitiesFiltered(options) {
+    return municipalities.filter(m => {
+        if (options.minPopulation !== undefined && m.k_population < options.minPopulation)
+            return false;
+        if (options.maxPopulation !== undefined && m.k_population > options.maxPopulation)
+            return false;
+        if (options.minArea !== undefined && m.k_area < options.minArea)
+            return false;
+        if (options.maxArea !== undefined && m.k_area > options.maxArea)
+            return false;
+        if (options.language !== undefined && m.k_language !== options.language)
+            return false;
+        if (options.countyId !== undefined && !m.k_id.startsWith(options.countyId))
+            return false;
+        return true;
+    });
+}
+/**
+ * Get total population of all municipalities.
+ * @returns Total population
+ */
+function getTotalPopulation() {
+    return municipalities.reduce((total, m) => total + m.k_population, 0);
+}
+/**
+ * Get total area of all municipalities.
+ * @returns Total area in square kilometers
+ */
+function getTotalArea() {
+    return municipalities.reduce((total, m) => total + m.k_area, 0);
+}
+/**
+ * Get population density statistics.
+ * @returns Object with min, max, and average population density
+ */
+function getPopulationDensityStats() {
+    const densities = municipalities.map(m => m.k_population / m.k_area);
+    return {
+        min: Math.min(...densities),
+        max: Math.max(...densities),
+        average: densities.reduce((sum, d) => sum + d, 0) / densities.length
+    };
+}
+/**
+ * Get municipalities by population density range.
+ * @param minDensity - Minimum population density (people per km²)
+ * @param maxDensity - Maximum population density (people per km²)
+ * @returns Array of municipalities within the density range
+ */
+function getMunicipalitiesByPopulationDensity(minDensity = 0, maxDensity = Infinity) {
+    return municipalities.filter(m => {
+        const density = m.k_population / m.k_area;
+        return density >= minDensity && density <= maxDensity;
+    });
+}
+/**
+ * Get the largest municipalities by population.
+ * @param count - Number of municipalities to return (default: 10)
+ * @returns Array of largest municipalities by population
+ */
+function getLargestMunicipalities(count = 10) {
+    return getMunicipalitiesByPopulation(false).slice(0, count);
+}
+/**
+ * Get the smallest municipalities by population.
+ * @param count - Number of municipalities to return (default: 10)
+ * @returns Array of smallest municipalities by population
+ */
+function getSmallestMunicipalities(count = 10) {
+    return getMunicipalitiesByPopulation(true).slice(0, count);
+}
+// ========================
+// POSTAL CODE FUNCTIONS
+// ========================
+/**
+ * Get all postal codes with metadata.
+ * @returns Array of all postal codes
+ */
+function getPostalCodes() {
+    return postalCodes;
+}
+/**
+ * Get postal code information by postal code.
+ * @param code - 4-digit postal code (e.g., "0001")
+ * @returns PostalCode object or undefined if not found
+ * @throws {TypeError} If code is not a string
+ */
+function getPostalCodeByCode(code) {
+    if (typeof code !== 'string') {
+        throw new TypeError('Postal code must be a string');
+    }
+    return postalCodes.find(pc => pc.k_postal_code === code);
+}
+/**
+ * Get postal codes by postal place (case-insensitive partial match by default).
+ * @param place - Postal place name or partial name to search for
+ * @param options - Search options
+ * @returns Array of matching postal codes
+ * @throws {TypeError} If place is not a string
+ */
+function getPostalCodesByPlace(place, options = {}) {
+    if (typeof place !== 'string') {
+        throw new TypeError('Postal place must be a string');
+    }
+    const { caseSensitive = false, exactMatch = false } = options;
+    const searchTerm = caseSensitive ? place : place.toLowerCase();
+    return postalCodes.filter(pc => {
+        const placeName = caseSensitive
+            ? pc.k_postal_place
+            : pc.k_postal_place.toLowerCase();
+        return exactMatch
+            ? placeName === searchTerm
+            : placeName.includes(searchTerm);
+    });
+}
+/**
+ * Get postal codes by municipality ID.
+ * @param municipalityId - 4-digit municipality ID (e.g., "0301" for Oslo)
+ * @returns Array of postal codes for the municipality
+ * @throws {TypeError} If municipalityId is not a string
+ */
+function getPostalCodesByMunicipalityId(municipalityId) {
+    if (typeof municipalityId !== 'string') {
+        throw new TypeError('Municipality ID must be a string');
+    }
+    return postalCodes.filter(pc => pc.k_id === municipalityId);
+}
+/**
+ * Get unique postal places.
+ * @returns Array of unique postal place names sorted alphabetically
+ */
+function getUniquePostalPlaces() {
+    const uniquePlaces = new Set();
+    postalCodes.forEach(pc => uniquePlaces.add(pc.k_postal_place));
+    return Array.from(uniquePlaces).sort();
+}
+/**
+ * Get postal codes within a range.
+ * @param startCode - Starting postal code (inclusive)
+ * @param endCode - Ending postal code (inclusive)
+ * @returns Array of postal codes within the range
+ * @throws {TypeError} If start or end codes are not strings
+ */
+function getPostalCodesInRange(startCode, endCode) {
+    if (typeof startCode !== 'string' || typeof endCode !== 'string') {
+        throw new TypeError('Start and end codes must be strings');
+    }
+    return postalCodes.filter(pc => pc.k_postal_code >= startCode && pc.k_postal_code <= endCode);
+}
+/**
+ * Get postal codes statistics.
+ * @returns Object with total count and unique places count
+ */
+function getPostalCodesStats() {
+    const uniquePlaces = new Set();
+    const uniqueMunicipalities = new Set();
+    postalCodes.forEach(pc => {
+        uniquePlaces.add(pc.k_postal_place);
+        uniqueMunicipalities.add(pc.k_id);
+    });
+    return {
+        totalPostalCodes: postalCodes.length,
+        uniquePlaces: uniquePlaces.size,
+        uniqueMunicipalities: uniqueMunicipalities.size
+    };
+}
+/**
+ * Get postal codes sorted by code.
+ * @param ascending - Sort in ascending order if true (default: true)
+ * @returns Array of postal codes sorted by postal code
+ */
+function getPostalCodesSorted(ascending = true) {
+    const sorted = [...postalCodes].sort((a, b) => ascending
+        ? a.k_postal_code.localeCompare(b.k_postal_code)
+        : b.k_postal_code.localeCompare(a.k_postal_code));
+    return sorted;
+}
+/**
+ * Check if a postal code exists.
+ * @param code - 4-digit postal code to check
+ * @returns True if postal code exists, false otherwise
+ */
+function isValidPostalCode(code) {
+    if (typeof code !== 'string') {
+        return false;
+    }
+    return postalCodes.some(pc => pc.k_postal_code === code);
+}
+/**
+ * Get postal codes by municipality name.
+ * Note: This function combines data from municipalities and postal codes.
+ * @param municipalityName - Municipality name to search for
+ * @param exactMatch - Whether to match exactly (default: false)
+ * @returns Array of postal codes for municipalities matching the name
+ */
+function getPostalCodesByMunicipalityName(municipalityName, exactMatch = false) {
+    const matchingMunicipalities = getMunicipalitiesByName(municipalityName, { exactMatch });
+    const municipalityIds = matchingMunicipalities.map(m => m.k_id);
+    return postalCodes.filter(pc => municipalityIds.includes(pc.k_id));
+}
+//# sourceMappingURL=index.js.map

package/dist/types.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Language status for Norwegian municipalities
+ */
+export type LanguageStatus = 'Nøytral' | 'Bokmål' | 'Nynorsk' | 'Sami' | 'Kvensk';
+/**
+ * Municipality (Kommune) data structure
+ */
+export interface Municipality {
+    /** 4-digit municipality ID */
+    readonly k_id: string;
+    /** Municipality name */
+    readonly k_name: string;
+    /** Municipality name in Norwegian */
+    readonly k_name_no: string;
+    /** Administrative center */
+    readonly k_adm_center: string;
+    /** Population count */
+    readonly k_population: number;
+    /** Area in square kilometers */
+    readonly k_area: number;
+    /** Official language status */
+    readonly k_language: LanguageStatus;
+    /** Official website URL */
+    readonly k_url: string;
+    /** Array of postal codes with place names */
+    readonly k_postal_codes: readonly {
+        /** 4-digit postal code */
+        readonly postal_code: string;
+        /** Place name */
+        readonly postal_place: string;
+    }[];
+}
+/**
+ * County (Fylke) data structure
+ */
+export interface County {
+    /** 2-digit county ID */
+    readonly f_id: string;
+    /** County name */
+    readonly f_name: string;
+    /** Official website URL */
+    readonly f_url: string;
+}
+/**
+ * Population density statistics
+ */
+export interface PopulationDensityStats {
+    /** Minimum population density (people per km²) */
+    readonly min: number;
+    /** Maximum population density (people per km²) */
+    readonly max: number;
+    /** Average population density (people per km²) */
+    readonly average: number;
+}
+/**
+ * Version bump types for semantic versioning
+ */
+export type VersionBumpType = 'patch' | 'minor' | 'major' | 'prerelease';
+/**
+ * Sort order options
+ */
+export type SortOrder = 'asc' | 'desc';
+/**
+ * Search options for municipalities
+ */
+export interface MunicipalitySearchOptions {
+    /** Search in both Norwegian and English names */
+    readonly includeAllNames?: boolean;
+    /** Case sensitive search */
+    readonly caseSensitive?: boolean;
+    /** Exact match only */
+    readonly exactMatch?: boolean;
+}
+/**
+ * Filter options for municipalities
+ */
+export interface MunicipalityFilterOptions {
+    /** Minimum population */
+    readonly minPopulation?: number;
+    /** Maximum population */
+    readonly maxPopulation?: number;
+    /** Minimum area (km²) */
+    readonly minArea?: number;
+    /** Maximum area (km²) */
+    readonly maxArea?: number;
+    /** Language status */
+    readonly language?: LanguageStatus;
+    /** County ID */
+    readonly countyId?: string;
+}
+/**
+ * Postal Code data structure
+ */
+export interface PostalCode {
+    /** 4-digit postal code */
+    readonly k_postal_code: string;
+    /** Postal place name */
+    readonly k_postal_place: string;
+    /** 4-digit municipality ID */
+    readonly k_id: string;
+}
+/**
+ * Search options for postal codes
+ */
+export interface PostalCodeSearchOptions {
+    /** Case sensitive search */
+    readonly caseSensitive?: boolean;
+    /** Exact match only */
+    readonly exactMatch?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@aprestmo/norway-geodata",
+  "version": "0.1.0",
+  "description": "Administrative geographic data for Norway including municipalities, counties, and postal codes.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.js"
+    },
+    "./data/municipalities": "./data/kommuner-2025.json",
+    "./data/counties": "./data/fylker-2025.json",
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "require": "./dist/types.js",
+      "import": "./dist/types.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=8.0.0"
+  },
+  "scripts": {
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -p tsconfig.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:watch": "tsc --watch",
+    "clean": "rimraf dist",
+    "prebuild": "npm run clean",
+    "test": "npm run build && node -e \"console.log('Running TypeScript validation...'); require('./dist/index.js'); console.log('✅ All exports working correctly!');\"",
+    "test:types": "tsc --noEmit",
+    "validate": "node scripts/validate-data.js",
+    "prepublishOnly": "npm run validate && npm run build && npm test",
+    "dev": "npm run build:watch",
+    "version:patch": "npm version patch --no-git-tag-version",
+    "version:minor": "npm version minor --no-git-tag-version",
+    "version:major": "npm version major --no-git-tag-version",
+    "version:prerelease": "npm version prerelease --no-git-tag-version",
+    "check-version": "npm view @aprestmo/norway-geodata version",
+    "check-conflicts": "node -e \"const pkg=require('./package.json'); const localVer=pkg.version; console.log('Local version:', localVer); require('child_process').exec('npm view @aprestmo/norway-geodata version', (err,stdout) => { if(err) { console.log('✅ Package not published yet - safe to publish'); return; } const remoteVer=stdout.trim(); console.log('Published version:', remoteVer); if(localVer===remoteVer) console.log('❌ Version conflict! Local version already published'); else console.log('✅ No conflicts - safe to publish'); });\"",
+    "version-status": "node -e \"const pkg=require('./package.json'); console.log('📦 Package:', pkg.name); console.log('🏷️  Local version:', pkg.version); require('child_process').exec('npm view @aprestmo/norway-geodata version', (err,stdout) => { if(err) { console.log('📡 Published: Not yet published'); } else { console.log('📡 Published version:', stdout.trim()); } });\"",
+    "publish:npm": "npm run check-conflicts && npm run prepublishOnly && npm publish --access public",
+    "publish:npm-dry": "npm run prepublishOnly && npm publish --dry-run",
+    "publish:github": "npm run prepublishOnly && npm publish --registry=https://npm.pkg.github.com",
+    "publish:both": "npm run publish:npm && npm run publish:github",
+    "release:patch": "npm run version:patch && npm run publish:npm",
+    "release:minor": "npm run version:minor && npm run publish:npm",
+    "release:major": "npm run version:major && npm run publish:npm"
+  },
+  "files": [
+    "dist",
+    "data",
+    "README.md",
+    "LICENSE",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*",
+    "!dist/**/*.map"
+  ],
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^22.0.0",
+    "jest": "^29.7.0",
+    "rimraf": "^6.0.1",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.6.0"
+  },
+  "keywords": [
+    "norway",
+    "geodata",
+    "municipalities",
+    "counties",
+    "postal-codes",
+    "kommune",
+    "fylke",
+    "typescript",
+    "types"
+  ],
+  "author": "Alexander Prestmo",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aprestmo/norway-geodata.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "overrides": {
+    "inflight": "npm:@lukekarrys/inflight@^1.0.4",
+    "glob": "^10.3.0"
+  }
+}