Refactoring: move all code files into a src directory

src/UI/Popup/ImportButtons/WayImportFlowState.ts

@@ -0,0 +1,139 @@
+import ImportFlow, { ImportFlowArguments } from "./ImportFlow"
+import { SpecialVisualizationState } from "../../SpecialVisualization"
+import { Feature, LineString, Polygon } from "geojson"
+import { Store, UIEventSource } from "../../../Logic/UIEventSource"
+import { Tag } from "../../../Logic/Tags/Tag"
+import { And } from "../../../Logic/Tags/And"
+import CreateWayWithPointReuseAction, {
+    MergePointConfig,
+} from "../../../Logic/Osm/Actions/CreateWayWithPointReuseAction"
+import { TagUtils } from "../../../Logic/Tags/TagUtils"
+import { OsmCreateAction, PreviewableAction } from "../../../Logic/Osm/Actions/OsmChangeAction"
+import { FeatureSource, IndexedFeatureSource } from "../../../Logic/FeatureSource/FeatureSource"
+import CreateMultiPolygonWithPointReuseAction from "../../../Logic/Osm/Actions/CreateMultiPolygonWithPointReuseAction"
+import LayoutConfig from "../../../Models/ThemeConfig/LayoutConfig"
+import { Changes } from "../../../Logic/Osm/Changes"
+import FullNodeDatabaseSource from "../../../Logic/FeatureSource/TiledFeatureSource/FullNodeDatabaseSource"
+
+export interface WayImportFlowArguments extends ImportFlowArguments {
+    max_snap_distance: string
+    snap_onto_layers: string
+    snap_to_layer_max_distance: string
+    max_move_distance: string
+    move_osm_point_if
+    snap_to_point_if
+}
+
+export default class WayImportFlowState extends ImportFlow<WayImportFlowArguments> {
+    public readonly originalFeature: Feature<LineString | Polygon>
+
+    private readonly action: OsmCreateAction & { getPreview?(): Promise<FeatureSource> }
+
+    constructor(
+        state: SpecialVisualizationState,
+        originalFeature: Feature<LineString | Polygon>,
+        args: WayImportFlowArguments,
+        tagsToApply: Store<Tag[]>,
+        originalFeatureTags: UIEventSource<Record<string, string>>
+    ) {
+        super(state, args, tagsToApply, originalFeatureTags)
+        this.originalFeature = originalFeature
+        const mergeConfigs = WayImportFlowState.GetMergeConfig(args)
+        this.action = WayImportFlowState.CreateAction(
+            originalFeature,
+            args,
+            state,
+            tagsToApply,
+            mergeConfigs
+        )
+    }
+
+    public static CreateAction(
+        feature: Feature<LineString | Polygon>,
+        args: WayImportFlowArguments,
+        state: {
+            layout: LayoutConfig
+            changes: Changes
+            indexedFeatures: IndexedFeatureSource
+            fullNodeDatabase?: FullNodeDatabaseSource
+        },
+        tagsToApply: Store<Tag[]>,
+        mergeConfigs: MergePointConfig[]
+    ): OsmCreateAction & PreviewableAction & { newElementId?: string } {
+        if (feature.geometry.type === "Polygon" && feature.geometry.coordinates.length > 1) {
+            const coors = (<Polygon>feature.geometry).coordinates
+            const outer = coors[0]
+            const inner = [...coors]
+            inner.splice(0, 1)
+            return new CreateMultiPolygonWithPointReuseAction(
+                tagsToApply.data,
+                outer,
+                inner,
+                state,
+                mergeConfigs,
+                "import"
+            )
+        } else if (feature.geometry.type === "Polygon") {
+            const coors = feature.geometry.coordinates
+
+            const outer = coors[0]
+            return new CreateWayWithPointReuseAction(tagsToApply.data, outer, state, mergeConfigs)
+        } else if (feature.geometry.type === "LineString") {
+            const coors = feature.geometry.coordinates
+            return new CreateWayWithPointReuseAction(tagsToApply.data, coors, state, mergeConfigs)
+        } else {
+            throw "Unsupported type"
+        }
+    }
+
+    public static GetMergeConfig(args: WayImportFlowArguments): MergePointConfig[] {
+        const nodesMustMatch = args.snap_to_point_if
+            ?.split(";")
+            ?.map((tag, i) => TagUtils.Tag(tag, "TagsSpec for import button " + i))
+
+        const mergeConfigs = []
+        if (nodesMustMatch !== undefined && nodesMustMatch.length > 0) {
+            const mergeConfig: MergePointConfig = {
+                mode: "reuse_osm_point",
+                ifMatches: new And(nodesMustMatch),
+                withinRangeOfM: Number(args.max_snap_distance),
+            }
+            mergeConfigs.push(mergeConfig)
+        }
+
+        const moveOsmPointIfTags = args["move_osm_point_if"]
+            ?.split(";")
+            ?.map((tag, i) => TagUtils.Tag(tag, "TagsSpec for import button " + i))
+
+        if (nodesMustMatch !== undefined && moveOsmPointIfTags.length > 0) {
+            const moveDistance = Math.min(20, Number(args["max_move_distance"]))
+            const mergeConfig: MergePointConfig = {
+                mode: "move_osm_point",
+                ifMatches: new And(moveOsmPointIfTags),
+                withinRangeOfM: moveDistance,
+            }
+            mergeConfigs.push(mergeConfig)
+        }
+
+        return mergeConfigs
+    }
+
+    // noinspection JSUnusedGlobalSymbols
+    public async onConfirm() {
+        const originalFeatureTags = this._originalFeatureTags
+        originalFeatureTags.data["_imported"] = "yes"
+        originalFeatureTags.ping() // will set isImported as per its definition
+        const action = this.action
+        await this.state.changes.applyAction(action)
+        const newId = action.newElementId ?? action.mainObjectId
+        this.state.selectedLayer.setData(this.targetLayer.layerDef)
+        this.state.selectedElement.setData(this.state.indexedFeatures.featuresById.data.get(newId))
+    }
+
+    public GetPreview(): undefined | Promise<FeatureSource> {
+        if (!this.action?.getPreview) {
+            return undefined
+        }
+        return this.action.getPreview()
+    }
+}