ansuko 1.1.1

package/dist/plugins/geo.d.ts

@@ -0,0 +1,25 @@
+import GeoJSON from "geojson";
+import { type AnsukoType } from "../index.js";
+/**
+ * Geometry type selector for conversions. Use `auto` to try higher dimensions first.
+ */
+export declare enum GeomType {
+    point = 0,
+    polygon = 1,
+    lineString = 2,
+    multiPoint = 3,
+    multiPolygon = 4,
+    multiLineString = 5,
+    auto = "auto"
+}
+export interface AnsukoGeoPluginExtension {
+    toPointGeoJson: (geo: any, digit?: number) => GeoJSON.Point | null;
+    toPolygonGeoJson: (geo: any, digit?: number) => GeoJSON.Polygon | null;
+    toLineStringGeoJson: (geo: any, digit?: number) => GeoJSON.LineString | null;
+    toMultiPointGeoJson: (geo: any, digit?: number) => GeoJSON.MultiPoint | null;
+    toMultiPolygonGeoJson: (geo: any, digit?: number) => GeoJSON.MultiPolygon | null;
+    toMultiLineStringGeoJson: (geo: any, digit?: number) => GeoJSON.MultiLineString | null;
+    unionPolygon: (geo: any, digit?: number) => GeoJSON.Polygon | GeoJSON.MultiPolygon | null;
+}
+declare const ansukoGeoPlugin: <T extends AnsukoType>(ansuko: T) => T & AnsukoGeoPluginExtension;
+export default ansukoGeoPlugin;

package/dist/plugins/geo.js

@@ -0,0 +1,566 @@
+import * as turf from "@turf/turf";
+/**
+ * Geometry type selector for conversions. Use `auto` to try higher dimensions first.
+ */
+export var GeomType;
+(function (GeomType) {
+    GeomType[GeomType["point"] = 0] = "point";
+    GeomType[GeomType["polygon"] = 1] = "polygon";
+    GeomType[GeomType["lineString"] = 2] = "lineString";
+    GeomType[GeomType["multiPoint"] = 3] = "multiPoint";
+    GeomType[GeomType["multiPolygon"] = 4] = "multiPolygon";
+    GeomType[GeomType["multiLineString"] = 5] = "multiLineString";
+    GeomType["auto"] = "auto";
+})(GeomType || (GeomType = {}));
+const ansukoGeoPlugin = (ansuko) => {
+    const _ = ansuko;
+    /**
+     * Converts a coordinate-like value to a [lng, lat] tuple, optionally rounding digits.
+     * Swaps order if lat/lng appear to be inverted. Returns null when invalid.
+     * @internal
+     */
+    const toLngLatToArray = (coord, digit) => {
+        if (_.isNil(coord)) {
+            return null;
+        }
+        let tLat = null;
+        let tLng = null;
+        if (Array.isArray(coord) && _.isNumber(coord[0]) && _.isNumber(coord[1])) {
+            tLng = _.toNumber(coord[0]);
+            tLat = _.toNumber(coord[1]);
+        }
+        else {
+            if (typeof coord !== "object") {
+                return null;
+            }
+            tLng = _.toNumber(coord.lng ?? coord.lon ?? coord.longitude);
+            tLat = _.toNumber(coord.lat ?? coord.latitude);
+        }
+        if (!tLat || !tLng) {
+            return null;
+        }
+        if (((tLat < -90 || tLat > 90) && (tLng > -90 && tLng < 90)) ||
+            ((tLng < -180 || tLng > 180) && (tLat > -180 && tLat < 180))) {
+            const t = tLat;
+            tLat = tLng;
+            tLat = t;
+        }
+        return [
+            (_.isNumber(digit) ? _.toNumber(tLng.toFixed(digit)) : tLng),
+            (_.isNumber(digit) ? _.toNumber(tLat.toFixed(digit)) : tLat)
+        ];
+    };
+    /**
+     * Converts coordinates or an object to a Point GeoJSON.
+     * @param geo - [lng,lat] or {lat,lng}
+     * @param digit - Rounding digits
+     * @returns Point or null
+     * @example toPointGeoJson([139.7671,35.6812])
+     * @example toPointGeoJson({ lat:35.6895, lng:139.6917 })
+     * @category Geo Utilities
+     */
+    const toPointGeoJson = (geo, digit) => {
+        let lngLat = null;
+        if (_.isEmpty(geo)) {
+            return null;
+        }
+        if (Array.isArray(geo)) {
+            if (_.size(geo) === 1) {
+                lngLat = toLngLatToArray(geo[0], digit);
+            }
+            else {
+                lngLat = toLngLatToArray(geo, digit);
+            }
+        }
+        else if (_.has(geo, "lat") || _.has(geo, "latitude")) {
+            lngLat = toLngLatToArray(geo, digit);
+        }
+        else if (_.has(geo, "type")) {
+            switch (geo.type.toLowerCase()) {
+                case "featurecollection":
+                    if (_.get(geo, "features[0].geometry.type")?.toLowerCase() !== "point") {
+                        return null;
+                    }
+                    if (_.size(geo.features) !== 1) {
+                        return null;
+                    }
+                    lngLat = toLngLatToArray(_.get(geo, "features[0].geometry.coordinates"), digit);
+                    break;
+                case "feature":
+                    if (geo.geometry?.type?.toLowerCase() !== "point") {
+                        return null;
+                    }
+                    lngLat = toLngLatToArray(geo.geometry?.coordinates, digit);
+                    break;
+                case "point":
+                    lngLat = toLngLatToArray(geo.coordinates, digit);
+                    break;
+                default:
+                    return null;
+            }
+        }
+        else {
+            return null;
+        }
+        if (!lngLat) {
+            return null;
+        } // null チェック追加
+        try {
+            return turf.point(lngLat)?.geometry;
+        }
+        catch {
+            return null;
+        }
+    };
+    /**
+     * Converts an outer ring to Polygon GeoJSON (ring must be closed).
+     * @param geo - [[lng,lat], ...] or Polygon-like GeoJSON
+     * @param digit - Rounding digits
+     * @returns Polygon or null
+     * @example toPolygonGeoJson([
+     *   [139.70,35.68],[139.78,35.68],[139.78,35.75],[139.70,35.75],[139.70,35.68]
+     * ])
+     * @category Geo Utilities
+     */
+    const toPolygonGeoJson = (geo, digit) => {
+        let ll = null;
+        if (_.arrayDepth(geo) === 3 && _.size(geo) === 1) { // [[外周リング]]
+            ll = _.first(geo).map((coord) => toLngLatToArray(coord, digit));
+        }
+        else if (_.arrayDepth(geo) === 2) { // [外周リング]
+            ll = geo.map((coord) => toLngLatToArray(coord, digit));
+        }
+        else if (_.has(geo, "type")) {
+            switch (_.get(geo, "type")?.toLowerCase()) {
+                case "featurecollection":
+                    if (_.get(geo, "features[0].geometry.type")?.toLowerCase() !== "polygon") {
+                        return null;
+                    }
+                    if (_.size(geo.features) !== 1) {
+                        return null;
+                    }
+                    // 最初のリング（外周）だけ取得
+                    ll = _.first(_.first(geo.features)?.geometry.coordinates)
+                        ?.map((coord) => toLngLatToArray(coord, digit));
+                    break;
+                case "feature":
+                    if (geo.geometry?.type?.toLowerCase() !== "polygon") {
+                        return null;
+                    }
+                    ll = _.first(geo.geometry.coordinates)?.map((coord) => toLngLatToArray(coord, digit));
+                    break;
+                case "polygon":
+                    ll = _.first(geo.coordinates)?.map((coord) => toLngLatToArray(coord, digit));
+                    break;
+                default:
+                    return null;
+            }
+        }
+        else {
+            return null;
+        }
+        if (!ll || ll.find(_.isEmpty)) {
+            return null;
+        }
+        if (!_.isEqual(_.first(ll), _.last(ll))) {
+            return null;
+        } // 閉じてるかチェック
+        try {
+            return turf.polygon([ll])?.geometry; // [ll] で囲む（外周リングの配列にする）
+        }
+        catch {
+            return null;
+        }
+    };
+    /**
+     * Converts coordinate sequence to LineString GeoJSON; returns null if self-intersecting.
+     * @param geo - [[lng,lat], ...] or LineString-like GeoJSON
+     * @param digit - Rounding digits
+     * @returns LineString or null
+     * @example toLineStringGeoJson([[139.70,35.68],[139.75,35.70],[139.80,35.72]])
+     * @category Geo Utilities
+     */
+    const toLineStringGeoJson = (geo, digit) => {
+        let ll = null;
+        if (_.arrayDepth(geo) === 3 && _.size(geo) === 1) {
+            ll = _.first(geo).map((l) => toLngLatToArray(l, digit));
+        }
+        else if (_.arrayDepth(geo) === 2) {
+            ll = geo.map((l) => toLngLatToArray(l, digit));
+        }
+        else if (_.has(geo, "type")) {
+            switch (_.get(geo, "type")?.toLowerCase()) {
+                case "featurecollection":
+                    if (_.get(geo, "features[0].geometry.type")?.toLowerCase() !== "linestring") {
+                        return null;
+                    }
+                    if (_.size(geo.features) !== 1) {
+                        return null;
+                    }
+                    ll = _.first(geo.features)?.geometry.coordinates?.map((l) => toLngLatToArray(l, digit));
+                    break;
+                case "feature":
+                    if (geo.geometry?.type?.toLowerCase() !== "linestring") {
+                        return null;
+                    }
+                    ll = geo.geometry?.coordinates?.map((l) => toLngLatToArray(l, digit));
+                    break;
+                case "linestring":
+                    ll = geo.coordinates?.map((l) => toLngLatToArray(l, digit));
+                    break;
+                default:
+                    return null;
+            }
+        }
+        else {
+            return null;
+        }
+        if (!ll || ll.find(_.isEmpty)) {
+            return null;
+        }
+        try {
+            const feature = turf.lineString(ll); // Feature を取得
+            if (!_.isEmpty(turf.kinks(feature)?.features)) {
+                return null;
+            } // 交差チェック
+            return feature.geometry; // Geometry を返す
+        }
+        catch {
+            return null;
+        }
+    };
+    /**
+     * Converts multiple points to MultiPoint GeoJSON.
+     * @param geo - [[lng,lat], ...] or MultiPoint-like GeoJSON
+     * @param digit - Rounding digits
+     * @returns MultiPoint or null
+     * @example toMultiPointGeoJson([[139.70,35.68],[139.71,35.69],[139.72,35.70]])
+     * @category Geo Utilities
+     */
+    const toMultiPointGeoJson = (geo, digit) => {
+        let ll = null;
+        if (_.arrayDepth(geo) === 2) { // MultiPointは2次元
+            ll = geo.map((coord) => toLngLatToArray(coord, digit));
+        }
+        else if (_.has(geo, "type")) {
+            switch (_.get(geo, "type")?.toLowerCase()) {
+                case "featurecollection":
+                    if (_.get(geo, "features[0].geometry.type")?.toLowerCase() !== "multipoint") {
+                        return null;
+                    }
+                    if (_.size(geo.features) !== 1) {
+                        return null;
+                    }
+                    ll = _.first(geo.features).geometry?.coordinates
+                        ?.map((coord) => toLngLatToArray(coord, digit));
+                    break;
+                case "feature":
+                    if (geo.geometry?.type?.toLowerCase() !== "multipoint") {
+                        return null;
+                    }
+                    ll = geo.geometry?.coordinates?.map((coord) => toLngLatToArray(coord, digit));
+                    break;
+                case "multipoint":
+                    ll = geo.coordinates?.map((coord) => toLngLatToArray(coord, digit));
+                    break;
+                default:
+                    return null;
+            }
+        }
+        else {
+            return null;
+        }
+        if (!ll || ll.find(_.isEmpty)) {
+            return null;
+        }
+        try {
+            return turf.multiPoint(ll)?.geometry;
+        }
+        catch {
+            return null;
+        }
+    };
+    /**
+     * Converts polygons (outer rings) to MultiPolygon GeoJSON.
+     * @param geo - Polygons
+     * @param digit - Rounding digits
+     * @returns MultiPolygon or null
+     * @example toMultiPolygonGeoJson([
+     *   [[[139.7,35.6],[139.8,35.6],[139.8,35.7],[139.7,35.7],[139.7,35.6]]],
+     *   [[[139.75,35.65],[139.85,35.65],[139.85,35.75],[139.75,35.75],[139.75,35.65]]]
+     * ])
+     * @category Geo Utilities
+     */
+    const toMultiPolygonGeoJson = (geo, digit) => {
+        let ll = null;
+        if (_.arrayDepth(geo) === 4) {
+            ll = geo.map((polygon) => _.first(polygon).map((l) => toLngLatToArray(l, digit)));
+        }
+        else if (_.has(geo, "type")) {
+            switch (geo.type.toLowerCase()) {
+                case "featurecollection":
+                    if (_.get(geo, "features[0].geometry.type")?.toLowerCase() !== "multipolygon") {
+                        return null;
+                    }
+                    if (_.size(geo.features) !== 1) {
+                        return null;
+                    }
+                    ll = _.first(geo.features).geometry?.coordinates?.map((polygon) => _.first(polygon).map((l) => toLngLatToArray(l, digit)));
+                    break;
+                case "feature":
+                    if (geo.geometry?.type?.toLowerCase() !== "multipolygon") {
+                        return null;
+                    }
+                    ll = geo.geometry?.coordinates?.map((polygon) => _.first(polygon).map((l) => toLngLatToArray(l, digit)));
+                    break;
+                case "multipolygon":
+                    ll = geo.coordinates?.map((polygon) => _.first(polygon).map((l) => toLngLatToArray(l, digit)));
+                    break;
+                default:
+                    return null;
+            }
+        }
+        else {
+            return null;
+        }
+        if (!ll || ll.find((polygon) => !polygon || polygon.find((ring) => !ring || ring.find(_.isEmpty)) || !_.isEqual(_.first(polygon), _.last(polygon)))) {
+            return null;
+        }
+        try {
+            return turf.multiPolygon(ll)?.geometry;
+        }
+        catch {
+            return null;
+        }
+    };
+    /**
+        * Converts lines to MultiLineString GeoJSON, rejecting self-intersections.
+        * @param geo - Lines
+        * @param digit - Rounding digits
+        * @returns MultiLineString or null
+        * @example toMultiLineStringGeoJson([
+ *   [[139.7,35.6],[139.8,35.65]],
+ *   [[139.75,35.62],[139.85,35.68]]
+ * ])
+ * @category Geo Utilities
+ */
+    const toMultiLineStringGeoJson = (geo, digit) => {
+        let ll = null;
+        if (_.arrayDepth(geo) === 3) {
+            ll = geo.map((line) => line.map((l) => toLngLatToArray(l, digit)));
+        }
+        else if (_.has(geo, "type")) {
+            switch (_.get(geo, "type").toLowerCase()) {
+                case "featurecollection":
+                    if (_.get(geo, "features[0].geometry.type")?.toLowerCase() !== "multilinestring") {
+                        return null;
+                    }
+                    if (_.size(geo.features) !== 1) {
+                        return null;
+                    }
+                    ll = _.first(geo.features).geometry?.coordinates?.map((line) => line.map((l) => toLngLatToArray(l, digit)));
+                    break;
+                case "feature":
+                    if (geo.geometry?.type?.toLowerCase() !== "multilinestring") {
+                        return null;
+                    } // 修正
+                    ll = geo.geometry?.coordinates?.map((line) => line.map((l) => toLngLatToArray(l, digit)));
+                    break;
+                case "multilinestring":
+                    ll = geo.coordinates?.map((line) => line.map((l) => toLngLatToArray(l, digit)));
+                    break;
+                default:
+                    return null;
+            }
+        }
+        if (!ll || ll.find((g) => !g || g.find(_.isEmpty))) {
+            return null;
+        }
+        try {
+            // 一旦linestringでチェック
+            if (ll.find((l) => {
+                const r = turf.lineString(l);
+                if (!r)
+                    return true;
+                const kinks = turf.kinks(r);
+                return !_.isEmpty(kinks.features);
+            })) {
+                return null;
+            }
+            return turf.multiLineString(ll)?.geometry;
+        }
+        catch {
+            return null;
+        }
+    };
+    /**
+     * Unions polygons into a single Polygon/MultiPolygon.
+     * @param geo - Polygon/MultiPolygon/FeatureCollection, etc.
+     * @param digit - Rounding digits
+     * @returns Unified geometry or null
+     * @example unionPolygon([
+     *   [[139.7,35.6],[139.8,35.6],[139.8,35.7],[139.7,35.7],[139.7,35.6]],
+     *   [[139.75,35.65],[139.85,35.65],[139.85,35.75],[139.75,35.75],[139.75,35.65]]
+     * ])
+     * @category Geo Utilities
+     */
+    const unionPolygon = (geo, digit) => {
+        let list = null;
+        const g = geo;
+        if (_.arrayDepth(geo) === 4) {
+            geo = _.first(geo);
+        }
+        if (Array.isArray(geo)) {
+            list = geo.map(g => {
+                const p = toPolygonGeoJson(g, digit);
+                return p ? turf.polygon(p.coordinates) : null;
+            }).filter(Boolean);
+        }
+        else if (_.has(geo, "type")) {
+            switch (_.get(g, "type")?.toLowerCase()) {
+                case "featurecollection":
+                    list = g.features?.map((f) => {
+                        const p = toPolygonGeoJson(f, digit);
+                        return p ? turf.polygon(p.coordinates) : null;
+                    }).filter(Boolean);
+                    break;
+                case "feature":
+                    if (g.geometry?.type !== "polygon") {
+                        return g;
+                    }
+                    else if (g.geometry?.type === "multipolygon") {
+                        list = g.geometry?.coordinates.map((c) => {
+                            const p = toPolygonGeoJson(c, digit);
+                            return p ? turf.polygon(p.coordinates) : null;
+                        }).filter(Boolean);
+                    }
+                    break;
+                case "polygon":
+                    return g;
+                case "multipolygon":
+                    list = g.coordinates.map((c) => {
+                        const p = toPolygonGeoJson(c, digit);
+                        return p ? turf.polygon(p.coordinates) : null;
+                    }).filter(Boolean);
+                    break;
+                default:
+                    return null;
+            }
+        }
+        else {
+            return null;
+        }
+        if (_.isEmpty(list)) {
+            return null;
+        }
+        if (_.size(list) === 1) {
+            return _.first(list).geometry;
+        }
+        return turf.union(turf.featureCollection(list))?.geometry ?? null;
+    };
+    /**
+     * Converts input to GeoJSON geometry of the given type. `auto` tries higher dimensions first.
+     * @param geo - Input
+     * @param type - GeomType
+     * @param digit - Rounding digits
+     * @returns Geometry or null
+     * @example toGeoJson([139.7,35.6], GeomType.point)
+     * @example toGeoJson([[139.7,35.6],[139.8,35.7]], GeomType.lineString)
+     * @example toGeoJson(
+     *   [[[139.7,35.6],[139.8,35.6],[139.8,35.7],[139.7,35.7],[139.7,35.6]]],
+     *   GeomType.polygon
+     * )
+     * @category Geo Utilities
+     */
+    const toGeoJson = (geo, type = GeomType.auto, digit) => {
+        if (_.isEmpty(geo)) {
+            return null;
+        }
+        if (typeof geo === "string") {
+            geo = _.parseJSON(geo);
+        }
+        switch (type) {
+            case GeomType.point:
+                return toPointGeoJson(geo, digit);
+            case GeomType.polygon:
+                return toPolygonGeoJson(geo, digit);
+            case GeomType.lineString:
+                return toLineStringGeoJson(geo, digit);
+            case GeomType.multiLineString:
+                return toMultiLineStringGeoJson(geo, digit);
+            case GeomType.multiPoint:
+                return toMultiPointGeoJson(geo, digit);
+            case GeomType.multiPolygon:
+                return toMultiPolygonGeoJson(geo, digit);
+            default:
+                break;
+        }
+        // auto: 次元の高い順に試す
+        return toMultiPolygonGeoJson(geo, digit)
+            ?? toMultiLineStringGeoJson(geo, digit)
+            ?? toPolygonGeoJson(geo, digit)
+            ?? toLineStringGeoJson(geo, digit)
+            ?? toMultiPointGeoJson(geo, digit)
+            ?? toPointGeoJson(geo, digit);
+    };
+    /**
+     * Converts inputs into a list of GeoJSON.Features suitable for TerraDraw.
+     * Multi-geometries are exploded into individual features and assigned UUIDs.
+     * @param geo - Geometry/Feature/FeatureCollection or nested arrays
+     * @returns Feature array (may be empty when input is invalid)
+     */
+    const parseToTerraDraw = (geo) => {
+        let feature = toGeoJson(geo, GeomType.auto);
+        if (_.isEmpty(feature) && Array.isArray(geo)) {
+            return geo.flatMap(parseToTerraDraw);
+        }
+        if (!feature)
+            return [];
+        const features = [];
+        const geom = feature.geometry; // 一度だけ
+        switch (geom.type) {
+            case "MultiPoint":
+                geom.coordinates.forEach((coord) => {
+                    const f = turf.point(coord, { mode: "point" });
+                    f.id = crypto.randomUUID();
+                    features.push(f);
+                });
+                break;
+            case "MultiLineString":
+                geom.coordinates.forEach((coords) => {
+                    const f = turf.lineString(coords, { mode: "linestring" });
+                    f.id = crypto.randomUUID();
+                    features.push(f);
+                });
+                break;
+            case "MultiPolygon":
+                geom.coordinates.forEach((coords) => {
+                    const f = turf.polygon(coords, { mode: "polygon" });
+                    f.id = crypto.randomUUID();
+                    features.push(f);
+                });
+                break;
+            default:
+                const f = { ...feature };
+                f.id = crypto.randomUUID();
+                f.properties = {
+                    ...f.properties,
+                    mode: geom.type.toLowerCase()
+                };
+                features.push(f);
+        }
+        return features;
+    };
+    const a = ansuko;
+    a.toGeoJson = toGeoJson;
+    a.toPointGeoJson = toPointGeoJson;
+    a.toPolygonGeoJson = toPolygonGeoJson;
+    a.toLineStringGeoJson = toLineStringGeoJson;
+    a.toMultiPointGeoJson = toMultiPointGeoJson;
+    a.toMultiLineStringGeoJson = toMultiLineStringGeoJson;
+    a.toMultiPolygonGeoJson = toMultiPolygonGeoJson;
+    a.unionPolygon = unionPolygon;
+    a.parseToTerraDraw = parseToTerraDraw;
+    return ansuko;
+};
+export default ansukoGeoPlugin;

package/dist/plugins/ja.d.ts

@@ -0,0 +1,13 @@
+import { type AnsukoType } from "../index.js";
+import { toHalfWidth, haifun } from "../util.js";
+export interface AnsukoJaExtension {
+    kanaToFull: (str: unknown) => string | null;
+    kanaToHalf: (str: unknown) => string | null;
+    kanaToHira: (str: unknown) => string | null;
+    hiraToKana: (str: unknown) => string | null;
+    toHalfWidth: typeof toHalfWidth;
+    toFullWidth: (value: unknown, withHaifun?: string) => string | null;
+    haifun: typeof haifun;
+}
+declare const ansukoJaPlugin: <T extends AnsukoType>(ansuko: T) => T & AnsukoJaExtension;
+export default ansukoJaPlugin;