@dra2020/district-analytics 16.1.2 → 16.1.4

package/dist/equal.d.ts

@@ -0,0 +1,3 @@
+import * as T from './types';
+import { AnalyticsSession } from './_api';
+export declare function doHasEqualPopulations(s: AnalyticsSession, bLog?: boolean): T.TestEntry;

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export * from './_api';
+export { geoIDForFeature, fieldForFeature, inferSelectedMinority } from './_data';
+export * from './results';
+export * from './types';
+export { Profile, Scorecard, SplittingScorecard, Measurement } from './legacy-types';
+export * from './utils';
+import { Partisan, Rate, Splitting, Types } from '@dra2020/dra-analytics';
+export type MinorityFilter = Types.MinorityFilter;
+export type Point = Types.dictPoint;
+export type DemographicVotingByFeature = Types.DemographicVotingByFeature;
+export type RPVFactor = Types.RPVFactor;
+export type RPVAnalysis = Types.RPVAnalysis;
+export declare const estSeatProbability: typeof Partisan.estSeatProbability;
+export declare const ratePartisanBias: typeof Rate.ratePartisanBias;
+export declare const normalizePartisanBias: typeof Rate.normalizePartisanBias;
+export declare const isAntimajoritarian: typeof Rate.isAntimajoritarian;
+export declare const avgSVError = 0.02;
+export declare const effectiveSplits: typeof Splitting.effectiveSplits;
+export declare const uncertaintyOfMembership: typeof Splitting.uncertaintyOfMembership;

package/dist/legacy-types.d.ts

@@ -0,0 +1,164 @@
+export type Profile = {
+    state: string;
+    name: string;
+    nDistricts: number;
+    repsByDistrict?: number[];
+    nCounties: number;
+    bStateLeg: boolean;
+    population: PopulationProfile;
+    shapes: ShapeProfile;
+    counties: CountyProfile;
+    partisanship: PartisanProfile;
+    demographics: DemographicProfile;
+};
+export type Scorecard = {
+    partisan: PartisanScorecard;
+    minority: MinorityScorecard;
+    compactness: CompactnessScorecard;
+    splitting: SplittingScorecard;
+    populationDeviation: PopulationScorecard;
+    details: Dict;
+};
+export type PartisanProfile = {
+    statewide: number;
+    byDistrict: VfArray;
+};
+export type VfArray = number[];
+export type PartisanScorecard = {
+    bias: Bias;
+    impact: Impact;
+    responsiveness: Responsiveness;
+    dSVpoints: SVpoint[];
+    rSVpoints: SVpoint[];
+    averageDVf: number | undefined;
+    averageRVf: number | undefined;
+    details: Dict;
+};
+export type rVpoints = {
+    Sb: number;
+    Ra: number;
+    Rb: number;
+    Va: number;
+    Vb: number;
+};
+export type Bias = {
+    bestS: number;
+    bestSf: number;
+    estS: number;
+    estSf: number;
+    deviation: number;
+    score: number;
+    tOf?: number;
+    fptpS?: number;
+    bS50?: number;
+    bV50?: number;
+    decl?: number | undefined;
+    rvPoints?: rVpoints;
+    gSym?: number;
+    gamma?: number;
+    eG?: number;
+    bSV?: number;
+    prop?: number;
+    mMs?: number;
+    mMd?: number;
+    lO?: number | undefined;
+};
+export type Impact = {
+    unearnedS: number;
+    score: number;
+};
+export type Responsiveness = {
+    bigR?: number | undefined;
+    littleR?: number | undefined;
+    mIR?: number | undefined;
+    rD?: number;
+    rDf?: number;
+    cSimple: number;
+    cD: number;
+    cDf: number;
+    score: number;
+};
+export type PopulationProfile = {
+    byDistrict: totalPopByDistrict;
+    targetSize: number;
+};
+export type totalPopByDistrict = number[];
+export type PopulationScorecard = Measurement;
+export type GeoProperties = {
+    area: number;
+    perimeter: number;
+    diameter: number;
+};
+export type ShapeProfile = GeoProperties[];
+export type CompactnessScorecard = {
+    score: number;
+    reock: Measurement;
+    polsby: Measurement;
+    details: Dict;
+};
+export type CompactnessByDistrict = {
+    rawReock: number;
+    normalizedReock: number;
+    rawPolsby: number;
+    normalizedPolsby: number;
+    kiwysiScore?: number;
+};
+export type CountyProfile = CxD;
+export type CxD = number[][];
+export type SplittingScorecard = {
+    score: number;
+    county: Measurement;
+    district: Measurement;
+    details: Dict;
+};
+export type Demographics = {
+    white: number;
+    minority: number;
+    black: number;
+    hispanic: number;
+    pacific: number;
+    asian: number;
+    native: number;
+};
+export type DemographicProfile = {
+    statewide: Demographics;
+    byDistrict: Demographics[];
+};
+export type DemoBreakdown = {
+    pct35_40: number;
+    pct40_45: number;
+    pct45_50: number;
+    pct50_55: number;
+    pct55_60: number;
+    pct60Plus: number;
+    vapPct: number;
+    propSeats: number;
+};
+export type DemographicPivot = {
+    minority: DemoBreakdown;
+    black: DemoBreakdown;
+    hispanic: DemoBreakdown;
+    pacific: DemoBreakdown;
+    asian: DemoBreakdown;
+    native: DemoBreakdown;
+};
+export type MinorityScorecard = {
+    pivotByDemographic: DemographicPivot;
+    opportunityDistricts: number;
+    coalitionDistricts: number;
+    score: number;
+    details: Dict;
+};
+export type Measurement = {
+    raw: number;
+    normalized: number;
+    byDistrict?: any[];
+    notes: Dict;
+};
+export type SVpoint = {
+    v: number;
+    s: number;
+};
+export type Dict = {
+    [key: string]: any;
+};

package/dist/minority.d.ts

@@ -0,0 +1,6 @@
+import { Types } from '@dra2020/dra-analytics';
+import * as T from './types';
+import { AnalyticsSession } from './_api';
+export declare function getMajorityMinority(s: AnalyticsSession): T.Dict;
+export declare function getVRASection5(s: AnalyticsSession): string;
+export declare function doAnalyzeRacialPolarization(s: AnalyticsSession, districtID: number, groups: Types.MinorityFilter, bLog?: boolean): Types.RPVAnalysis | undefined;

package/dist/preprocess.d.ts

@@ -0,0 +1,2 @@
+import { AnalyticsSession } from './_api';
+export declare function doPreprocessData(s: AnalyticsSession, bLog?: boolean): void;

package/dist/results.d.ts

@@ -0,0 +1,50 @@
+import * as T from './types';
+import { AnalyticsSession } from './_api';
+export type RequirementsChecklist = {
+    score: boolean;
+    metrics: {
+        complete: boolean;
+        contiguous: boolean;
+        freeOfHoles: boolean;
+        equalPopulation: boolean;
+    };
+    details: {
+        unassignedFeatures: string[];
+        emptyDistricts: number[];
+        discontiguousDistricts: number[];
+        embeddedDistricts: number[];
+        populationDeviation: number;
+        deviationThreshold: number;
+    };
+    datasets: T.Datasets;
+    resources: {};
+};
+export declare function prepareRequirementsChecklist(s: AnalyticsSession, bLog?: boolean): RequirementsChecklist;
+export type DistrictRow = {
+    districtID: number;
+    totalPop: number;
+    popDevPct: number;
+    bEqualPop: boolean;
+    bNotEmpty: boolean;
+    bContiguous: boolean;
+    bNotEmbedded: boolean;
+    demPct: number;
+    repPct: number;
+    othPct: number;
+    totalVAP: number;
+    whitePct: number;
+    minorityPct: number;
+    blackPct: number;
+    hispanicPct: number;
+    pacificPct: number;
+    asianPct: number;
+    nativePct: number;
+};
+export type DistrictStatistics = {
+    table: DistrictRow[];
+    details: {};
+    datasets: T.Datasets;
+    resources: {};
+};
+export declare function prepareDistrictStatistics(s: AnalyticsSession, bLog?: boolean): DistrictStatistics;
+export declare function doAnalyzePostProcessing(s: AnalyticsSession, bLog?: boolean): void;

package/dist/score.d.ts

@@ -0,0 +1,9 @@
+import * as L from './legacy-types';
+import * as T from './types';
+import { AnalyticsSession } from './_api';
+import { Types } from '@dra2020/dra-analytics';
+export declare function profilePlan(s: AnalyticsSession, bLog?: boolean): L.Profile;
+export declare function getStatewideDemographics(s: AnalyticsSession, bLog?: boolean): L.Demographics;
+export declare function computeMetrics(p: L.Profile, districtShapes: T.GeoFeatureCollection, bLog?: boolean): Types.Scorecard;
+export declare function rateKeyDimensions(scorecard: Types.Scorecard, p: L.Profile, bLog?: boolean): Types.Scorecard;
+export declare function thunkScorecard(newScorecard: Types.Scorecard, bLog?: boolean): L.Scorecard;

package/dist/settings.d.ts

@@ -0,0 +1,4 @@
+export declare const PRECISION: number;
+export declare const NOT_ASSIGNED: number;
+export declare const NUMBER_OF_ITEMS_TO_REPORT: number;
+export declare const OUT_OF_STATE: string;

package/dist/src/types.d.ts

@@ -1,5 +1,5 @@
 import * as geojson from 'geojson';
-import * as DT from '@dra2020/dra-types';
+import { DT } from '@dra2020/dra-types';
 export type SessionRequest = {
     title: string;
     stateXX: string;
@@ -82,8 +82,8 @@ export declare const enum Test {
     Complete = 0,
     Contiguous = 1,
     FreeOfHoles = 2,
-    EqualPopulation = 3,
-    PopulationDeviation = 4,
+    EqualPopulation = 3,// This is the legal/not legal assessment of the population 
+    PopulationDeviation = 4,// deviation % (when legal, less is still better).
     UnexpectedCountySplits = 5,
     VTDSplits = 6
 }

package/dist/types.d.ts

@@ -0,0 +1,126 @@
+import * as geojson from 'geojson';
+import { DT } from '@dra2020/dra-types';
+export type SessionRequest = {
+    title: string;
+    stateXX: string;
+    nDistricts: number;
+    repsByDistrict?: number[];
+    planType?: DT.PlanType;
+    legislativeDistricts?: boolean;
+    plan: PlanByGeoID;
+    data: GeoFeatureCollection;
+    districtShapes: GeoFeatureCollection;
+    graph: ContiguityGraph;
+    counties: GeoFeatureCollection;
+    config: {};
+};
+export declare const enum Dataset {
+    SHAPES = "SHAPES",
+    CENSUS = "CENSUS",
+    VAP = "VAP",
+    ELECTION = "ELECTION"
+}
+export type DatasetKeys = {
+    SHAPES: string;
+    CENSUS: string;
+    VAP: string;
+    ELECTION: string;
+};
+export declare const enum FeatureField {
+    TotalPop = 0,
+    WhitePop = 1,
+    BlackPop = 2,
+    HispanicPop = 3,
+    AsianPop = 4,
+    PacificPop = 5,
+    NativePop = 6,
+    DemVotes = 7,
+    RepVotes = 8,
+    TotalVotes = 9
+}
+export declare function fieldFromFeatureField(ds: string, ff: FeatureField): string;
+export type PlanByGeoID = {
+    [geoID: string]: number;
+};
+export type PlanByDistrictID = {
+    [districtID: number]: Set<string>;
+};
+export type FeaturesByGeoID = {
+    [geoID: string]: number;
+};
+export type FIPSCodeToCountyNameMap = {
+    [FIPSCode: string]: string;
+};
+export type FIPSToOrdinalMap = {
+    [FIPSCode: string]: number;
+};
+export type OrdinalToFIPSlMap = {
+    [index: number]: string;
+};
+export type GeoFeature = geojson.Feature;
+export type GeoFeatureArray = GeoFeature[];
+export type GeoFeatureCollection = geojson.FeatureCollection;
+export interface GeoFeatureMap {
+    [geoID: string]: GeoFeature;
+}
+export type ContiguityGraph = {
+    [geoID: string]: UnweightedNeighbors | WeightedNeighbors;
+};
+export type WeightedNeighbors = {
+    [geoID: string]: number;
+};
+export type UnweightedNeighbors = string[];
+export type TestEntry = {
+    score?: number | boolean;
+    details: Dict;
+    normalizedScore?: number;
+};
+export type DistrictWIP = {
+    [districtID: number]: any;
+};
+export declare const enum Test {
+    Complete = 0,
+    Contiguous = 1,
+    FreeOfHoles = 2,
+    EqualPopulation = 3,// This is the legal/not legal assessment of the population 
+    PopulationDeviation = 4,// deviation % (when legal, less is still better).
+    UnexpectedCountySplits = 5,
+    VTDSplits = 6
+}
+export type TestEntries = {
+    [test: number]: TestEntry;
+};
+export type DistrictProperties = {
+    [districtID: number]: any;
+};
+export type DistrictShapeProperties = [number, number, number];
+export declare const enum DistrictShapeProperty {
+    Area = 0,
+    Diameter = 1,
+    Perimeter = 2
+}
+export type GeoIDParts = {
+    vfeature?: boolean;
+    state: string;
+    county: string;
+    rest: string;
+};
+export type GeoIDTotal = {
+    [geoID: string]: number;
+};
+export type Dict = {
+    [key: string]: any;
+};
+export type Datasets = {
+    shapes?: string;
+    census?: string;
+    vap?: string;
+    election?: string;
+};
+export type Ratings = {
+    proportionality: number;
+    competitiveness: number;
+    minorityRights: number;
+    compactness: number;
+    splitting: number;
+};

package/dist/utils.d.ts

@@ -0,0 +1,26 @@
+import { AnalyticsSession } from './_api';
+import * as T from './types';
+export declare function getDistrict(plan: T.PlanByGeoID, geoID: string): number | undefined;
+export declare function parseGeoID(geoID: string): T.GeoIDParts;
+export declare function isWaterOnly(geoID: string, s?: AnalyticsSession): boolean;
+export declare function isUninhabited(geoID: string, s: AnalyticsSession): boolean;
+export declare function trim(fullFraction: number, digits?: number | undefined): number;
+export declare function sumArray(arr: number[]): number;
+export declare function avgArray(arr: number[]): number;
+export declare function minArray(arr: number[]): number;
+export declare function maxArray(arr: number[]): number;
+export declare function initArray(n: number, value: any): any[];
+export declare function andArray(arr: boolean[]): boolean;
+export declare function keyExists(k: string, o: object): boolean;
+export declare function isObjectEmpty(o: object): boolean;
+export declare function isSetEmpty(s: any): boolean;
+export declare function isArrayEmpty(a: any[]): boolean;
+export declare function getObjectKeys(o: object): string[];
+export declare function getNumericObjectKeys(o: object): number[];
+export declare function getSelectObjectKeys(o: T.Dict, v: any[]): string[];
+export declare function arrayContains(a: any[], item: any): boolean;
+export declare function objectContains(o: object, key: any): boolean;
+export declare function countEnumValues(enumName: any): number;
+export declare function shallowCopy(src: any): any;
+export declare function deepCopy(src: any): any;
+export declare function depthof(a: any): number;

package/dist/valid.d.ts

@@ -0,0 +1,5 @@
+import * as T from './types';
+import { AnalyticsSession } from './_api';
+export declare function doIsComplete(s: AnalyticsSession, bLog?: boolean): T.TestEntry;
+export declare function doIsContiguous(s: AnalyticsSession, bLog?: boolean): T.TestEntry;
+export declare function doIsFreeOfHoles(s: AnalyticsSession, bLog?: boolean): T.TestEntry;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dra2020/district-analytics",
-  "version": "16.1.2",
+  "version": "16.1.4",
   "description": "District analytics TypeScript package",
   "main": "dist/district-analytics.js",
   "files": [
@@ -30,24 +30,24 @@
   "homepage": "https://github.com/dra2020/district-analytics#readme",
   "devDependencies": {
     "@types/geojson": "^7946.0.10",
-    "@types/node": "^12.20.23",
+    "@types/node": "^20.11.30",
     "@types/yargs": "^12.0.20",
     "json-loader": "^0.5.7",
     "prettier": "^2.7.1",
-    "source-map-loader": "^3.0.0",
-    "ts-loader": "^9.4.1",
+    "source-map-loader": "^5.0.0",
+    "ts-loader": "^9.5.1",
     "tsify": "^5.0.4",
     "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0",
-    "typescript": "^4.9.3",
-    "webpack": "^5.75.0",
-    "webpack-cli": "^4.10.0",
+    "typescript": "^5.4.3",
+    "webpack": "^5.91.0",
+    "webpack-cli": "^5.1.4",
     "yargs": "^12.0.5"
   },
   "dependencies": {
-    "@dra2020/baseclient": "^1.0.90",
+    "@dra2020/baseclient": "^1.0.127",
     "@dra2020/dra-analytics": "^4.1.2",
-    "@dra2020/dra-types": "^1.8.71",
+    "@dra2020/dra-types": "^1.8.89",
     "geojson": "^0.5.0"
   }
 }