From 0d79173e5d384e328c00cc5926eb5f82f538ab10 Mon Sep 17 00:00:00 2001 From: babayaga Date: Tue, 25 Nov 2025 11:07:35 +0100 Subject: [PATCH] cleanup --- packages/search/dist-in/lib/email.d.ts | 14 +- packages/search/dist-in/lib/email.js | 2 +- packages/search/dist-in/lib/google.d.ts | 132 +++ packages/search/dist-in/lib/google.js | 14 + .../search/dist-in/lib/googlemaps-utils.d.ts | 13 + .../search/dist-in/lib/googlemaps-utils.js | 89 ++ .../search/dist-in/lib/googlemaps-zod.d.ts | 981 ++++++++++++++++++ packages/search/dist-in/lib/googlemaps-zod.js | 161 +++ packages/search/dist-in/lib/googlemaps.d.ts | 10 +- packages/search/dist-in/lib/googlemaps.js | 91 +- packages/search/dist-in/lib/html.d.ts | 9 +- packages/search/dist-in/lib/html.js | 83 +- packages/search/dist-in/lib/map_types.d.ts | 128 ++- packages/search/dist-in/lib/resolve.d.ts | 3 + packages/search/dist-in/lib/resolve.js | 5 + packages/search/package.json | 6 +- packages/search/src/lib/email.ts | 12 +- packages/search/src/lib/google.ts | 251 +++-- packages/search/src/lib/googlemaps-utils.ts | 103 ++ packages/search/src/lib/googlemaps-zod.ts | 190 ++++ packages/search/src/lib/googlemaps.ts | 126 ++- packages/search/src/lib/html.ts | 110 +- packages/search/src/lib/map_types.ts | 145 ++- .../maps/barcelona/spain/all/all-10.xls | Bin 0 -> 18594 bytes .../maps/barcelona/spain/all/all-10.xls.json | 163 +++ .../spain/category/plastichub-10.xls | Bin 0 -> 18834 bytes .../spain/category/plastichub-10.xls.json | 347 +++++++ .../spain/category/plastichub-10_options.json | 34 + .../maps/barcelona/spain/search-media.json | 304 ++++++ 29 files changed, 3206 insertions(+), 320 deletions(-) create mode 100644 packages/search/dist-in/lib/google.d.ts create mode 100644 packages/search/dist-in/lib/google.js create mode 100644 packages/search/dist-in/lib/googlemaps-utils.d.ts create mode 100644 packages/search/dist-in/lib/googlemaps-utils.js create mode 100644 packages/search/dist-in/lib/googlemaps-zod.d.ts create mode 100644 packages/search/dist-in/lib/googlemaps-zod.js create mode 100644 packages/search/dist-in/lib/resolve.d.ts create mode 100644 packages/search/dist-in/lib/resolve.js create mode 100644 packages/search/src/lib/googlemaps-utils.ts create mode 100644 packages/search/src/lib/googlemaps-zod.ts create mode 100644 packages/search/test/campaign/maps/barcelona/spain/all/all-10.xls create mode 100644 packages/search/test/campaign/maps/barcelona/spain/all/all-10.xls.json create mode 100644 packages/search/test/campaign/maps/barcelona/spain/category/plastichub-10.xls create mode 100644 packages/search/test/campaign/maps/barcelona/spain/category/plastichub-10.xls.json create mode 100644 packages/search/test/campaign/maps/barcelona/spain/category/plastichub-10_options.json create mode 100644 packages/search/test/campaign/maps/barcelona/spain/search-media.json diff --git a/packages/search/dist-in/lib/email.d.ts b/packages/search/dist-in/lib/email.d.ts index dc902aa1..36aebb1c 100644 --- a/packages/search/dist-in/lib/email.d.ts +++ b/packages/search/dist-in/lib/email.d.ts @@ -3,8 +3,14 @@ import { LocalResult } from './map_types.js'; export declare class HtmlToTextTransformer extends MappingDocumentTransformer { static lc_name(): string; constructor(options?: {}); - _transformDocument(document: any): Promise>; + _transformDocument(document: Document): Promise>; } -export declare const cheerioLoader: (url: any) => Promise; -export declare const puppeteerLoader: (url: any, headless: any, location: LocalResult) => Promise; -export declare const findEMail: (question: string, url: string, opts: any, location: LocalResult) => Promise; +export declare const cheerioLoader: (url: string) => Promise; +export declare const puppeteerLoader: (url: string, headless: boolean, location: LocalResult) => Promise; +export declare const findEMail: (question: string, url: string, opts: { + headless?: boolean; + searchFrom?: string; + [key: string]: any; +}, location: LocalResult) => Promise; diff --git a/packages/search/dist-in/lib/email.js b/packages/search/dist-in/lib/email.js index 29ddd1f7..7fc2ea2a 100644 --- a/packages/search/dist-in/lib/email.js +++ b/packages/search/dist-in/lib/email.js @@ -111,4 +111,4 @@ export const findEMail = async (question, url, opts, location) => { location.email && logger.debug(`Found email for ${url} / ${location.title} : ${location.type} : ${location.email} : ${opts.searchFrom}`); return emails; }; -//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/packages/search/dist-in/lib/google.d.ts b/packages/search/dist-in/lib/google.d.ts new file mode 100644 index 00000000..95232e53 --- /dev/null +++ b/packages/search/dist-in/lib/google.d.ts @@ -0,0 +1,132 @@ +import { LocationSiteMeta } from "./map_types.js"; +export declare enum GoogleSearchUrls { + EN = "https://www.google.com/", + DE = "https://www.google.de/", + FR = "https://www.google.fr/", + ES = "https://www.google.es/", + IT = "https://www.google.it/", + PT = "https://www.google.pt/", + RU = "https://www.google.ru/", + JP = "https://www.google.co.jp/", + ZH = "https://www.google.com.hk/", + UK = "https://www.google.co.uk/" +} +export interface GpsCoordinates { + latitude: number; + longitude: number; +} +export interface OperatingHours { + thursday: string; + friday: string; + saturday: string; + sunday: string; + monday: string; + tuesday: string; + wednesday: string; +} +export interface Geo { + latitude: number; + lookupSource: string; + longitude: number; + localityLanguageRequested: string; + continent: string; + continentCode: string; + countryName: string; + countryCode: string; + principalSubdivision: string; + principalSubdivisionCode: string; + city: string; + locality: string; + postcode: string; + plusCode: string; + localityInfo: LocalityInfo; +} +export interface LocalityInfo { + administrative: Administrative[]; + informative: Informative[]; +} +export interface Administrative { + name: string; + description: string; + isoName?: string; + order: number; + adminLevel: number; + isoCode?: string; + wikidataId: string; + geonameId: number; +} +export interface Informative { + name: string; + description?: string; + isoName?: string; + order: number; + isoCode?: string; + wikidataId?: string; + geonameId?: number; +} +export interface GoogleMapResult { + position: number; + title: string; + place_id: string; + data_id: string; + data_cid: string; + reviews_link: string; + photos_link: string; + gps_coordinates: GpsCoordinates; + place_id_search: string; + provider_id: string; + rating: number; + reviews: number; + type: string; + types: string[]; + address: string; + open_state: string; + hours: string; + operating_hours: OperatingHours; + website: string; + thumbnail: string; + geo: Geo; +} +export interface GoogleMapResultEx extends GoogleMapResult { + email?: string; +} +export interface GoogleMapPhotos { + search_metadata: SearchMetadata; + search_parameters: SearchParameters; + categories: Category[]; + photos: Photo[]; + serpapi_pagination: SerpapiPagination; +} +export interface SearchMetadata { + id: string; + status: string; + json_endpoint: string; + created_at: string; + processed_at: string; + google_maps_photos_url: string; + raw_html_file: string; + prettify_html_file: string; + total_time_taken: number; +} +export interface SearchParameters { + engine: string; + data_id: string; + hl: string; +} +export interface Category { + title: string; + id: string; +} +export interface Photo { + thumbnail: string; + image: string; + photo_meta_serpapi_link: string; +} +export interface SerpapiPagination { + next: string; + next_page_token: string; +} +export interface GoogleMapResultInternal extends GoogleMapResultEx { + google_media?: GoogleMapPhotos; + meta?: LocationSiteMeta; +} diff --git a/packages/search/dist-in/lib/google.js b/packages/search/dist-in/lib/google.js new file mode 100644 index 00000000..a1cfeddf --- /dev/null +++ b/packages/search/dist-in/lib/google.js @@ -0,0 +1,14 @@ +export var GoogleSearchUrls; +(function (GoogleSearchUrls) { + GoogleSearchUrls["EN"] = "https://www.google.com/"; + GoogleSearchUrls["DE"] = "https://www.google.de/"; + GoogleSearchUrls["FR"] = "https://www.google.fr/"; + GoogleSearchUrls["ES"] = "https://www.google.es/"; + GoogleSearchUrls["IT"] = "https://www.google.it/"; + GoogleSearchUrls["PT"] = "https://www.google.pt/"; + GoogleSearchUrls["RU"] = "https://www.google.ru/"; + GoogleSearchUrls["JP"] = "https://www.google.co.jp/"; + GoogleSearchUrls["ZH"] = "https://www.google.com.hk/"; + GoogleSearchUrls["UK"] = "https://www.google.co.uk/"; +})(GoogleSearchUrls || (GoogleSearchUrls = {})); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ29vZ2xlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2xpYi9nb29nbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxDQUFOLElBQVksZ0JBV1g7QUFYRCxXQUFZLGdCQUFnQjtJQUMxQixrREFBOEIsQ0FBQTtJQUM5QixpREFBNkIsQ0FBQTtJQUM3QixpREFBNkIsQ0FBQTtJQUM3QixpREFBNkIsQ0FBQTtJQUM3QixpREFBNkIsQ0FBQTtJQUM3QixpREFBNkIsQ0FBQTtJQUM3QixpREFBNkIsQ0FBQTtJQUM3QixvREFBZ0MsQ0FBQTtJQUNoQyxxREFBaUMsQ0FBQTtJQUNqQyxvREFBZ0MsQ0FBQTtBQUNsQyxDQUFDLEVBWFcsZ0JBQWdCLEtBQWhCLGdCQUFnQixRQVczQiJ9 \ No newline at end of file diff --git a/packages/search/dist-in/lib/googlemaps-utils.d.ts b/packages/search/dist-in/lib/googlemaps-utils.d.ts new file mode 100644 index 00000000..1b822519 --- /dev/null +++ b/packages/search/dist-in/lib/googlemaps-utils.d.ts @@ -0,0 +1,13 @@ +export type ParsedURL = { + scheme: string; + host?: string; + path?: string; + query?: Record; + fragment?: string; +}; +export declare const escapeFirstUrlSegment: (url: string) => string; +export declare const handleFs: (path: string) => Promise; +export declare const schemeHandlers: Record Promise>; +export declare const parseCustomUrl: (url: string) => Promise; +export declare const resolvePath: (str: string, query: any, category: any, opts: any) => string; +export declare const cleanObjectStrings: (obj: any) => any; diff --git a/packages/search/dist-in/lib/googlemaps-utils.js b/packages/search/dist-in/lib/googlemaps-utils.js new file mode 100644 index 00000000..bf810cb9 --- /dev/null +++ b/packages/search/dist-in/lib/googlemaps-utils.js @@ -0,0 +1,89 @@ +import * as path from 'path'; +import { URL } from 'url'; +import { isFile, resolve } from '@polymech/commons'; +import { sync as read } from '@polymech/fs/read'; +import { sync as exists } from '@polymech/fs/exists'; +export const escapeFirstUrlSegment = (url) => { + const schemeEndIndex = url.indexOf('://') + 3; + const restOfUrl = url.slice(schemeEndIndex); + const questionMarkIndex = restOfUrl.indexOf('?'); + if (questionMarkIndex !== -1) { + const firstSegment = restOfUrl.slice(0, questionMarkIndex); + const escapedFirstSegment = encodeURIComponent(firstSegment); + return url.slice(0, schemeEndIndex) + escapedFirstSegment + restOfUrl.slice(questionMarkIndex); + } + else { + const escapedFirstSegment = encodeURIComponent(restOfUrl); + return url.slice(0, schemeEndIndex) + escapedFirstSegment; + } +}; +export const handleFs = async (path) => { + return read(path); +}; +export const schemeHandlers = { + // 'osr-ai': handleOsrAi, + 'fs': handleFs, + 'default': handleFs +}; +export const parseCustomUrl = async (url) => { + if (!url.includes('://')) { + const _path = path.resolve(resolve(url)); + if (exists(_path) && isFile(_path)) { + return read(_path, 'json'); + } + } + const parsedUrl = new URL(escapeFirstUrlSegment(url)); + let scheme = parsedUrl.protocol.replace(':', '') || 'default'; + const handler = schemeHandlers[scheme]; + let result = null; + if (handler) { + if (scheme === 'osr-ai') { + result = await handler(parsedUrl.hostname, parsedUrl.searchParams); + } + else { + result = await handler(parsedUrl.pathname); + } + } + return result || url; +}; +export const resolvePath = (str, query, category, opts) => { + return path.resolve(resolve(str, false, { + QUERY: query, + FROM: opts.searchFrom ? opts.searchFrom.split(',').map((s) => s.trim()).join('/') : 'barcelona, spain', + ENGINE: opts.engine, + DOMAIN: opts.google_domain, + LANG: opts.language, + COUNTRY: opts.country, + AREA: opts.area, + CATEGORY: category || 'unknown', + ...opts.variables || {} + })); +}; +const cleanString = (str) => { + if (typeof str !== 'string') { + return str; + } + return str + .replace(/\u202F/g, ' ') // narrow no-break space + .replace(/\u2013/g, '-') // en dash + .replace(/\u2019/g, "'"); // right single quotation mark +}; +export const cleanObjectStrings = (obj) => { + if (!obj) { + return obj; + } + if (Array.isArray(obj)) { + return obj.map(item => cleanObjectStrings(item)); + } + if (typeof obj === 'object') { + return Object.entries(obj).reduce((acc, [key, value]) => { + acc[key] = cleanObjectStrings(value); + return acc; + }, {}); + } + if (typeof obj === 'string') { + return cleanString(obj); + } + return obj; +}; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/packages/search/dist-in/lib/googlemaps-zod.d.ts b/packages/search/dist-in/lib/googlemaps-zod.d.ts new file mode 100644 index 00000000..5796d879 --- /dev/null +++ b/packages/search/dist-in/lib/googlemaps-zod.d.ts @@ -0,0 +1,981 @@ +import { z } from 'zod'; +import * as CLI from 'yargs'; +export declare enum ResolveFlags { + PHOTOS = "PHOTOS" +} +export declare const zodSchemaBase: () => z.ZodObject<{ + api_key: z.ZodOptional; + blacklist: z.ZodOptional>>; + cache: z.ZodDefault; + category: z.ZodDefault>; + concurrency: z.ZodDefault; + dst: z.ZodOptional; + dump: z.ZodOptional; + engine: z.ZodDefault; + env_key: z.ZodDefault; + filterCity: z.ZodOptional; + filterCountry: z.ZodOptional; + filterContinent: z.ZodOptional; + filterType: z.ZodOptional; + findEMail: z.ZodDefault; + geocode_key: z.ZodOptional; + google_domain: z.ZodDefault; + headless: z.ZodDefault; + language: z.ZodDefault; + limit: z.ZodDefault; + logLevel: z.ZodDefault; + meta: z.ZodDefault; + searchCache: z.ZodDefault; + query: z.ZodDefault; + resolve: z.ZodOptional, "many">>>; + searchCoord: z.ZodOptional; + searchFrom: z.ZodDefault>; + source: z.ZodOptional>]>>; + type: z.ZodDefault>; + zoom: z.ZodDefault>; + index: z.ZodDefault; + store: z.ZodDefault; + variables: z.ZodOptional; +}, "passthrough", z.ZodTypeAny, z.objectOutputType<{ + api_key: z.ZodOptional; + blacklist: z.ZodOptional>>; + cache: z.ZodDefault; + category: z.ZodDefault>; + concurrency: z.ZodDefault; + dst: z.ZodOptional; + dump: z.ZodOptional; + engine: z.ZodDefault; + env_key: z.ZodDefault; + filterCity: z.ZodOptional; + filterCountry: z.ZodOptional; + filterContinent: z.ZodOptional; + filterType: z.ZodOptional; + findEMail: z.ZodDefault; + geocode_key: z.ZodOptional; + google_domain: z.ZodDefault; + headless: z.ZodDefault; + language: z.ZodDefault; + limit: z.ZodDefault; + logLevel: z.ZodDefault; + meta: z.ZodDefault; + searchCache: z.ZodDefault; + query: z.ZodDefault; + resolve: z.ZodOptional, "many">>>; + searchCoord: z.ZodOptional; + searchFrom: z.ZodDefault>; + source: z.ZodOptional>]>>; + type: z.ZodDefault>; + zoom: z.ZodDefault>; + index: z.ZodDefault; + store: z.ZodDefault; + variables: z.ZodOptional; +}, z.ZodTypeAny, "passthrough">, z.objectInputType<{ + api_key: z.ZodOptional; + blacklist: z.ZodOptional>>; + cache: z.ZodDefault; + category: z.ZodDefault>; + concurrency: z.ZodDefault; + dst: z.ZodOptional; + dump: z.ZodOptional; + engine: z.ZodDefault; + env_key: z.ZodDefault; + filterCity: z.ZodOptional; + filterCountry: z.ZodOptional; + filterContinent: z.ZodOptional; + filterType: z.ZodOptional; + findEMail: z.ZodDefault; + geocode_key: z.ZodOptional; + google_domain: z.ZodDefault; + headless: z.ZodDefault; + language: z.ZodDefault; + limit: z.ZodDefault; + logLevel: z.ZodDefault; + meta: z.ZodDefault; + searchCache: z.ZodDefault; + query: z.ZodDefault; + resolve: z.ZodOptional, "many">>>; + searchCoord: z.ZodOptional; + searchFrom: z.ZodDefault>; + source: z.ZodOptional>]>>; + type: z.ZodDefault>; + zoom: z.ZodDefault>; + index: z.ZodDefault; + store: z.ZodDefault; + variables: z.ZodOptional; +}, z.ZodTypeAny, "passthrough">>; +export declare const zodSchema: () => z.ZodEffects; + blacklist: z.ZodOptional>>; + cache: z.ZodDefault; + category: z.ZodDefault>; + concurrency: z.ZodDefault; + dst: z.ZodOptional; + dump: z.ZodOptional; + engine: z.ZodDefault; + env_key: z.ZodDefault; + filterCity: z.ZodOptional; + filterCountry: z.ZodOptional; + filterContinent: z.ZodOptional; + filterType: z.ZodOptional; + findEMail: z.ZodDefault; + geocode_key: z.ZodOptional; + google_domain: z.ZodDefault; + headless: z.ZodDefault; + language: z.ZodDefault; + limit: z.ZodDefault; + logLevel: z.ZodDefault; + meta: z.ZodDefault; + searchCache: z.ZodDefault; + query: z.ZodDefault; + resolve: z.ZodOptional, "many">>>; + searchCoord: z.ZodOptional; + searchFrom: z.ZodDefault>; + source: z.ZodOptional>]>>; + type: z.ZodDefault>; + zoom: z.ZodDefault>; + index: z.ZodDefault; + store: z.ZodDefault; + variables: z.ZodOptional; +}, "passthrough", z.ZodTypeAny, z.objectOutputType<{ + api_key: z.ZodOptional; + blacklist: z.ZodOptional>>; + cache: z.ZodDefault; + category: z.ZodDefault>; + concurrency: z.ZodDefault; + dst: z.ZodOptional; + dump: z.ZodOptional; + engine: z.ZodDefault; + env_key: z.ZodDefault; + filterCity: z.ZodOptional; + filterCountry: z.ZodOptional; + filterContinent: z.ZodOptional; + filterType: z.ZodOptional; + findEMail: z.ZodDefault; + geocode_key: z.ZodOptional; + google_domain: z.ZodDefault; + headless: z.ZodDefault; + language: z.ZodDefault; + limit: z.ZodDefault; + logLevel: z.ZodDefault; + meta: z.ZodDefault; + searchCache: z.ZodDefault; + query: z.ZodDefault; + resolve: z.ZodOptional, "many">>>; + searchCoord: z.ZodOptional; + searchFrom: z.ZodDefault>; + source: z.ZodOptional>]>>; + type: z.ZodDefault>; + zoom: z.ZodDefault>; + index: z.ZodDefault; + store: z.ZodDefault; + variables: z.ZodOptional; +}, z.ZodTypeAny, "passthrough">, z.objectInputType<{ + api_key: z.ZodOptional; + blacklist: z.ZodOptional>>; + cache: z.ZodDefault; + category: z.ZodDefault>; + concurrency: z.ZodDefault; + dst: z.ZodOptional; + dump: z.ZodOptional; + engine: z.ZodDefault; + env_key: z.ZodDefault; + filterCity: z.ZodOptional; + filterCountry: z.ZodOptional; + filterContinent: z.ZodOptional; + filterType: z.ZodOptional; + findEMail: z.ZodDefault; + geocode_key: z.ZodOptional; + google_domain: z.ZodDefault; + headless: z.ZodDefault; + language: z.ZodDefault; + limit: z.ZodDefault; + logLevel: z.ZodDefault; + meta: z.ZodDefault; + searchCache: z.ZodDefault; + query: z.ZodDefault; + resolve: z.ZodOptional, "many">>>; + searchCoord: z.ZodOptional; + searchFrom: z.ZodDefault>; + source: z.ZodOptional>]>>; + type: z.ZodDefault>; + zoom: z.ZodDefault>; + index: z.ZodDefault; + store: z.ZodDefault; + variables: z.ZodOptional; +}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{ + api_key: z.ZodOptional; + blacklist: z.ZodOptional>>; + cache: z.ZodDefault; + category: z.ZodDefault>; + concurrency: z.ZodDefault; + dst: z.ZodOptional; + dump: z.ZodOptional; + engine: z.ZodDefault; + env_key: z.ZodDefault; + filterCity: z.ZodOptional; + filterCountry: z.ZodOptional; + filterContinent: z.ZodOptional; + filterType: z.ZodOptional; + findEMail: z.ZodDefault; + geocode_key: z.ZodOptional; + google_domain: z.ZodDefault; + headless: z.ZodDefault; + language: z.ZodDefault; + limit: z.ZodDefault; + logLevel: z.ZodDefault; + meta: z.ZodDefault; + searchCache: z.ZodDefault; + query: z.ZodDefault; + resolve: z.ZodOptional, "many">>>; + searchCoord: z.ZodOptional; + searchFrom: z.ZodDefault>; + source: z.ZodOptional>]>>; + type: z.ZodDefault>; + zoom: z.ZodDefault>; + index: z.ZodDefault; + store: z.ZodDefault; + variables: z.ZodOptional; +}, z.ZodTypeAny, "passthrough">, z.objectInputType<{ + api_key: z.ZodOptional; + blacklist: z.ZodOptional>>; + cache: z.ZodDefault; + category: z.ZodDefault>; + concurrency: z.ZodDefault; + dst: z.ZodOptional; + dump: z.ZodOptional; + engine: z.ZodDefault; + env_key: z.ZodDefault; + filterCity: z.ZodOptional; + filterCountry: z.ZodOptional; + filterContinent: z.ZodOptional; + filterType: z.ZodOptional; + findEMail: z.ZodDefault; + geocode_key: z.ZodOptional; + google_domain: z.ZodDefault; + headless: z.ZodDefault; + language: z.ZodDefault; + limit: z.ZodDefault; + logLevel: z.ZodDefault; + meta: z.ZodDefault; + searchCache: z.ZodDefault; + query: z.ZodDefault; + resolve: z.ZodOptional, "many">>>; + searchCoord: z.ZodOptional; + searchFrom: z.ZodDefault>; + source: z.ZodOptional>]>>; + type: z.ZodDefault>; + zoom: z.ZodDefault>; + index: z.ZodDefault; + store: z.ZodDefault; + variables: z.ZodOptional; +}, z.ZodTypeAny, "passthrough">>; +export declare const zodSchemaEachExtras: () => z.ZodObject<{ + logLevel: z.ZodDefault; + log: z.ZodOptional; + country: z.ZodString; + area: z.ZodString; + list: z.ZodString; + cwd: z.ZodDefault>; + env: z.ZodDefault; + profile: z.ZodDefault; + migrate: z.ZodDefault; +}, "strip", z.ZodTypeAny, { + logLevel?: string; + log?: string; + country?: string; + area?: string; + list?: string; + cwd?: string; + env?: string; + profile?: string; + migrate?: boolean; +}, { + logLevel?: string; + log?: string; + country?: string; + area?: string; + list?: string; + cwd?: string; + env?: string; + profile?: string; + migrate?: boolean; +}>; +export declare const zodSchemaEach: () => z.ZodEffects; + blacklist: z.ZodOptional>>; + cache: z.ZodDefault; + category: z.ZodDefault>; + concurrency: z.ZodDefault; + dst: z.ZodOptional; + dump: z.ZodOptional; + engine: z.ZodDefault; + env_key: z.ZodDefault; + filterCity: z.ZodOptional; + filterCountry: z.ZodOptional; + filterContinent: z.ZodOptional; + filterType: z.ZodOptional; + findEMail: z.ZodDefault; + geocode_key: z.ZodOptional; + google_domain: z.ZodDefault; + headless: z.ZodDefault; + language: z.ZodDefault; + limit: z.ZodDefault; + meta: z.ZodDefault; + searchCache: z.ZodDefault; + query: z.ZodDefault; + resolve: z.ZodOptional, "many">>>; + searchCoord: z.ZodOptional; + searchFrom: z.ZodDefault>; + source: z.ZodOptional>]>>; + type: z.ZodDefault>; + zoom: z.ZodDefault>; + index: z.ZodDefault; + store: z.ZodDefault; + variables: z.ZodOptional; +} & { + logLevel: z.ZodDefault; + log: z.ZodOptional; + country: z.ZodString; + area: z.ZodString; + list: z.ZodString; + cwd: z.ZodDefault>; + env: z.ZodDefault; + profile: z.ZodDefault; + migrate: z.ZodDefault; +}, "strip", z.ZodTypeAny, { + api_key?: string; + type?: string; + blacklist?: string[]; + cache?: boolean; + category?: string; + concurrency?: number; + dst?: string; + dump?: string; + engine?: string; + env_key?: string; + filterCity?: string; + filterCountry?: string; + filterContinent?: string; + filterType?: string; + findEMail?: boolean; + geocode_key?: string; + google_domain?: string; + headless?: boolean; + language?: string; + limit?: number; + logLevel?: string; + meta?: boolean; + searchCache?: boolean; + query?: string; + resolve?: ResolveFlags.PHOTOS[]; + searchCoord?: string; + searchFrom?: string; + source?: string | Record; + zoom?: number; + index?: string; + store?: string; + variables?: any; + log?: string; + country?: string; + area?: string; + list?: string; + cwd?: string; + env?: string; + profile?: string; + migrate?: boolean; +}, { + api_key?: string; + type?: string; + blacklist?: string[]; + cache?: boolean; + category?: string; + concurrency?: number; + dst?: string; + dump?: string; + engine?: string; + env_key?: string; + filterCity?: string; + filterCountry?: string; + filterContinent?: string; + filterType?: string; + findEMail?: boolean; + geocode_key?: string; + google_domain?: string; + headless?: boolean; + language?: string; + limit?: number; + logLevel?: string; + meta?: boolean; + searchCache?: boolean; + query?: string; + resolve?: ResolveFlags.PHOTOS[]; + searchCoord?: string; + searchFrom?: string; + source?: string | Record; + zoom?: number; + index?: string; + store?: string; + variables?: any; + log?: string; + country?: string; + area?: string; + list?: string; + cwd?: string; + env?: string; + profile?: string; + migrate?: boolean; +}>, { + api_key?: string; + type?: string; + blacklist?: string[]; + cache?: boolean; + category?: string; + concurrency?: number; + dst?: string; + dump?: string; + engine?: string; + env_key?: string; + filterCity?: string; + filterCountry?: string; + filterContinent?: string; + filterType?: string; + findEMail?: boolean; + geocode_key?: string; + google_domain?: string; + headless?: boolean; + language?: string; + limit?: number; + logLevel?: string; + meta?: boolean; + searchCache?: boolean; + query?: string; + resolve?: ResolveFlags.PHOTOS[]; + searchCoord?: string; + searchFrom?: string; + source?: string | Record; + zoom?: number; + index?: string; + store?: string; + variables?: any; + log?: string; + country?: string; + area?: string; + list?: string; + cwd?: string; + env?: string; + profile?: string; + migrate?: boolean; +}, { + api_key?: string; + type?: string; + blacklist?: string[]; + cache?: boolean; + category?: string; + concurrency?: number; + dst?: string; + dump?: string; + engine?: string; + env_key?: string; + filterCity?: string; + filterCountry?: string; + filterContinent?: string; + filterType?: string; + findEMail?: boolean; + geocode_key?: string; + google_domain?: string; + headless?: boolean; + language?: string; + limit?: number; + logLevel?: string; + meta?: boolean; + searchCache?: boolean; + query?: string; + resolve?: ResolveFlags.PHOTOS[]; + searchCoord?: string; + searchFrom?: string; + source?: string | Record; + zoom?: number; + index?: string; + store?: string; + variables?: any; + log?: string; + country?: string; + area?: string; + list?: string; + cwd?: string; + env?: string; + profile?: string; + migrate?: boolean; +}>; +export type IOptionsGoogleMaps = z.infer>; +export type IOptionsGoogleMapsInput = z.input>; +export type IOptionsGoogleMapsEach = z.infer>; +export type IOptionsGoogleMapsEachInput = z.input>; +export declare const yargsOptions: (yargs: CLI.Argv) => CLI.Argv; +export declare const yargsOptionsEach: (yargs: CLI.Argv) => CLI.Argv; +export declare const meta_schema: z.ZodObject<{ + og: z.ZodObject<{ + url: z.ZodString; + type: z.ZodString; + title: z.ZodString; + site_name: z.ZodString; + }, "strip", z.ZodTypeAny, { + type?: string; + url?: string; + title?: string; + site_name?: string; + }, { + type?: string; + url?: string; + title?: string; + site_name?: string; + }>; + meta: z.ZodObject<{ + url: z.ZodString; + title: z.ZodString; + }, "strip", z.ZodTypeAny, { + url?: string; + title?: string; + }, { + url?: string; + title?: string; + }>; + links: z.ZodArray; + images: z.ZodArray, "many">; + allLinks: z.ZodArray; + keywords: z.ZodArray; + instagram: z.ZodString; + structured: z.ZodArray; + breadcrumb: z.ZodObject<{ + "@id": z.ZodString; + }, "strip", z.ZodTypeAny, { + "@id"?: string; + }, { + "@id"?: string; + }>; + inLanguage: z.ZodString; + dateModified: z.ZodString; + datePublished: z.ZodString; + potentialAction: z.ZodArray; + }, "strip", z.ZodTypeAny, { + "@type"?: string; + target?: string[]; + }, { + "@type"?: string; + target?: string[]; + }>, "many">; + }, "strip", z.ZodTypeAny, { + url?: string; + "@id"?: string; + name?: string; + "@type"?: string; + isPartOf?: { + "@id"?: string; + }; + breadcrumb?: { + "@id"?: string; + }; + inLanguage?: string; + dateModified?: string; + datePublished?: string; + potentialAction?: { + "@type"?: string; + target?: string[]; + }[]; + }, { + url?: string; + "@id"?: string; + name?: string; + "@type"?: string; + isPartOf?: { + "@id"?: string; + }; + breadcrumb?: { + "@id"?: string; + }; + inLanguage?: string; + dateModified?: string; + datePublished?: string; + potentialAction?: { + "@type"?: string; + target?: string[]; + }[]; + }>, z.ZodObject<{ + "@id": z.ZodString; + "@type": z.ZodString; + itemListElement: z.ZodArray, "many">; + }, "strip", z.ZodTypeAny, { + "@id"?: string; + "@type"?: string; + itemListElement?: { + name?: string; + "@type"?: string; + position?: number; + }[]; + }, { + "@id"?: string; + "@type"?: string; + itemListElement?: { + name?: string; + "@type"?: string; + position?: number; + }[]; + }>, z.ZodObject<{ + "@id": z.ZodString; + url: z.ZodString; + name: z.ZodString; + "@type": z.ZodString; + inLanguage: z.ZodString; + description: z.ZodString; + potentialAction: z.ZodArray; + "query-input": z.ZodObject<{ + "@type": z.ZodString; + valueName: z.ZodString; + valueRequired: z.ZodBoolean; + }, "strip", z.ZodTypeAny, { + "@type"?: string; + valueName?: string; + valueRequired?: boolean; + }, { + "@type"?: string; + valueName?: string; + valueRequired?: boolean; + }>; + }, "strip", z.ZodTypeAny, { + "@type"?: string; + target?: { + "@type"?: string; + urlTemplate?: string; + }; + "query-input"?: { + "@type"?: string; + valueName?: string; + valueRequired?: boolean; + }; + }, { + "@type"?: string; + target?: { + "@type"?: string; + urlTemplate?: string; + }; + "query-input"?: { + "@type"?: string; + valueName?: string; + valueRequired?: boolean; + }; + }>, "many">; + }, "strip", z.ZodTypeAny, { + url?: string; + "@id"?: string; + name?: string; + "@type"?: string; + inLanguage?: string; + potentialAction?: { + "@type"?: string; + target?: { + "@type"?: string; + urlTemplate?: string; + }; + "query-input"?: { + "@type"?: string; + valueName?: string; + valueRequired?: boolean; + }; + }[]; + description?: string; + }, { + url?: string; + "@id"?: string; + name?: string; + "@type"?: string; + inLanguage?: string; + potentialAction?: { + "@type"?: string; + target?: { + "@type"?: string; + urlTemplate?: string; + }; + "query-input"?: { + "@type"?: string; + valueName?: string; + valueRequired?: boolean; + }; + }[]; + description?: string; + }>]>, "many">; + "@context": z.ZodString; + }, "strip", z.ZodTypeAny, { + "@graph"?: ({ + url?: string; + "@id"?: string; + name?: string; + "@type"?: string; + isPartOf?: { + "@id"?: string; + }; + breadcrumb?: { + "@id"?: string; + }; + inLanguage?: string; + dateModified?: string; + datePublished?: string; + potentialAction?: { + "@type"?: string; + target?: string[]; + }[]; + } | { + "@id"?: string; + "@type"?: string; + itemListElement?: { + name?: string; + "@type"?: string; + position?: number; + }[]; + } | { + url?: string; + "@id"?: string; + name?: string; + "@type"?: string; + inLanguage?: string; + potentialAction?: { + "@type"?: string; + target?: { + "@type"?: string; + urlTemplate?: string; + }; + "query-input"?: { + "@type"?: string; + valueName?: string; + valueRequired?: boolean; + }; + }[]; + description?: string; + })[]; + "@context"?: string; + }, { + "@graph"?: ({ + url?: string; + "@id"?: string; + name?: string; + "@type"?: string; + isPartOf?: { + "@id"?: string; + }; + breadcrumb?: { + "@id"?: string; + }; + inLanguage?: string; + dateModified?: string; + datePublished?: string; + potentialAction?: { + "@type"?: string; + target?: string[]; + }[]; + } | { + "@id"?: string; + "@type"?: string; + itemListElement?: { + name?: string; + "@type"?: string; + position?: number; + }[]; + } | { + url?: string; + "@id"?: string; + name?: string; + "@type"?: string; + inLanguage?: string; + potentialAction?: { + "@type"?: string; + target?: { + "@type"?: string; + urlTemplate?: string; + }; + "query-input"?: { + "@type"?: string; + valueName?: string; + valueRequired?: boolean; + }; + }[]; + description?: string; + })[]; + "@context"?: string; + }>, "many">; +}, "strip", z.ZodTypeAny, { + meta?: { + url?: string; + title?: string; + }; + og?: { + type?: string; + url?: string; + title?: string; + site_name?: string; + }; + links?: unknown[]; + images?: { + src?: string; + }[]; + allLinks?: string[]; + keywords?: unknown[]; + instagram?: string; + structured?: { + "@graph"?: ({ + url?: string; + "@id"?: string; + name?: string; + "@type"?: string; + isPartOf?: { + "@id"?: string; + }; + breadcrumb?: { + "@id"?: string; + }; + inLanguage?: string; + dateModified?: string; + datePublished?: string; + potentialAction?: { + "@type"?: string; + target?: string[]; + }[]; + } | { + "@id"?: string; + "@type"?: string; + itemListElement?: { + name?: string; + "@type"?: string; + position?: number; + }[]; + } | { + url?: string; + "@id"?: string; + name?: string; + "@type"?: string; + inLanguage?: string; + potentialAction?: { + "@type"?: string; + target?: { + "@type"?: string; + urlTemplate?: string; + }; + "query-input"?: { + "@type"?: string; + valueName?: string; + valueRequired?: boolean; + }; + }[]; + description?: string; + })[]; + "@context"?: string; + }[]; +}, { + meta?: { + url?: string; + title?: string; + }; + og?: { + type?: string; + url?: string; + title?: string; + site_name?: string; + }; + links?: unknown[]; + images?: { + src?: string; + }[]; + allLinks?: string[]; + keywords?: unknown[]; + instagram?: string; + structured?: { + "@graph"?: ({ + url?: string; + "@id"?: string; + name?: string; + "@type"?: string; + isPartOf?: { + "@id"?: string; + }; + breadcrumb?: { + "@id"?: string; + }; + inLanguage?: string; + dateModified?: string; + datePublished?: string; + potentialAction?: { + "@type"?: string; + target?: string[]; + }[]; + } | { + "@id"?: string; + "@type"?: string; + itemListElement?: { + name?: string; + "@type"?: string; + position?: number; + }[]; + } | { + url?: string; + "@id"?: string; + name?: string; + "@type"?: string; + inLanguage?: string; + potentialAction?: { + "@type"?: string; + target?: { + "@type"?: string; + urlTemplate?: string; + }; + "query-input"?: { + "@type"?: string; + valueName?: string; + valueRequired?: boolean; + }; + }[]; + description?: string; + })[]; + "@context"?: string; + }[]; +}>; diff --git a/packages/search/dist-in/lib/googlemaps-zod.js b/packages/search/dist-in/lib/googlemaps-zod.js new file mode 100644 index 00000000..ea5e6c3b --- /dev/null +++ b/packages/search/dist-in/lib/googlemaps-zod.js @@ -0,0 +1,161 @@ +import { z } from 'zod'; +import { toYargs } from '@polymech/commons'; +export var ResolveFlags; +(function (ResolveFlags) { + ResolveFlags["PHOTOS"] = "PHOTOS"; +})(ResolveFlags || (ResolveFlags = {})); +const o = { + query: "plastichub", + engine: "google_maps", + type: "search", + q: "plastichub", + ll: "@41.6911354,2.1652746,13z", + google_domain: "google.es", + hl: "en", + searchFrom: "barcelona, spain", + api_key: "517879d08bd8f13df9c4265c42aea8cfe960942f3a10e8774bbec11becbfb687", + geocode_key: "65bcf01943459613018206nmi9830a9", + openai: { + key: "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", + "key-p": "sk-x9O7hWAAeDCdX6HVyv49R2NV7JhFjGhUj7gG5szBoBT3BlbkFJfzB9Mo7j8Yl3xevSgeoSR-GXpftEevoS4ybwJrcWsA", + }, + headless: false, + bigdata: { + key: "bdc_26a67478a1f1492faf5cec9c498da553", + }, +}; +// Base schema without transformation - allows merging +export const zodSchemaBase = () => z.object({ + api_key: z.string().optional().describe('API Key'), + blacklist: z + .array(z.string()) + .default(['bazar.preciousplastic.com']) + .describe('A list of hostnames to exclude from the results').optional(), + cache: z.boolean().default(false), + category: z.string().optional().default('category'), + concurrency: z.number().default(3).describe('The concurrency level for async operations'), + dst: z.string().optional().describe('${POLYMECH_ROOT}/campaign/maps/${FROM}/${CATEGORY}/${QUERY}-10.xls'), + dump: z.string().optional(), + engine: z.string().default('google_maps'), + env_key: z.string().default('OSR-CONFIG'), + filterCity: z.string().optional(), + filterCountry: z.string().optional(), + filterContinent: z.string().optional(), + filterType: z.string().optional(), + findEMail: z.boolean().default(false), + geocode_key: z.string().optional(), + google_domain: z.string().default('google.com'), + headless: z.boolean().default(true).describe('Headless mode'), + language: z.string().default('en'), + limit: z.number().default(5), + logLevel: z.string().default('info'), + meta: z.boolean().default(true), + searchCache: z.boolean().default(false).describe('Use search cache'), + query: z.string().default('plastichub'), + resolve: z.array(z.nativeEnum(ResolveFlags)).default([ResolveFlags.PHOTOS]).optional(), + searchCoord: z.string().optional(), + searchFrom: z.string().optional().default('barcelona, spain'), + source: z.union([z.string(), z.record(z.string(), z.array(z.string()))]).optional(), + type: z.string().optional().default('search'), + zoom: z.number().optional().default(13), + index: z.string().default('${OSR_ROOT}/osr-directory/meta/index.json').describe('Index file'), + store: z.string().default('${OSR_ROOT}/osr-directory/meta/index.db').describe('Index store'), + variables: z.any().optional(), +}) + .passthrough(); +// Schema with transformation applied +export const zodSchema = () => zodSchemaBase() + .transform((data) => { + if (!data.source) { + data.source = { + [data.category || 'unknown']: [data.query], + }; + } + return data; +}); +export const zodSchemaEachExtras = () => z.object({ + logLevel: z.string().default('info'), + log: z.string().optional(), + country: z.string().describe('The country to search in, variable ${COUNTRY}'), + area: z.string().describe('The city to search in, variable ${AREA}'), + list: z.string().describe('List of items to process, FILE|GLOB|AI-Query, provided as ${TOWN}'), + cwd: z.string().optional().default('./').describe('the current working directory to use, otherwise . is being assumed'), + env: z.string().default(''), + profile: z.string().default('${OSR_ROOT}/osr-templates/osrl/.osrl.json'), + migrate: z.boolean().default(false), +}); +// Merge the base schemas first, then apply transformation +export const zodSchemaEach = () => zodSchemaBase() + .merge(zodSchemaEachExtras()) + .transform((data) => { + if (!data.source) { + data.source = { + [data.category || 'unknown']: [data.query], + }; + } + return data; +}) + .describe('IOptionsGoogleMapsEach'); +export const yargsOptions = (yargs) => toYargs(yargs, zodSchema()); +export const yargsOptionsEach = (yargs) => toYargs(yargs, zodSchemaEach()); +export const meta_schema = z.object({ + og: z.object({ + url: z.string(), + type: z.string(), + title: z.string(), + site_name: z.string() + }), + meta: z.object({ url: z.string(), title: z.string() }), + links: z.array(z.unknown()), + images: z.array(z.object({ src: z.string() })), + allLinks: z.array(z.string()), + keywords: z.array(z.unknown()), + instagram: z.string(), + structured: z.array(z.object({ + "@graph": z.array(z.union([ + z.object({ + "@id": z.string(), + url: z.string(), + name: z.string(), + "@type": z.string(), + isPartOf: z.object({ "@id": z.string() }), + breadcrumb: z.object({ "@id": z.string() }), + inLanguage: z.string(), + dateModified: z.string(), + datePublished: z.string(), + potentialAction: z.array(z.object({ "@type": z.string(), target: z.array(z.string()) })) + }), + z.object({ + "@id": z.string(), + "@type": z.string(), + itemListElement: z.array(z.object({ + name: z.string(), + "@type": z.string(), + position: z.number() + })) + }), + z.object({ + "@id": z.string(), + url: z.string(), + name: z.string(), + "@type": z.string(), + inLanguage: z.string(), + description: z.string(), + potentialAction: z.array(z.object({ + "@type": z.string(), + target: z.object({ + "@type": z.string(), + urlTemplate: z.string() + }), + "query-input": z.object({ + "@type": z.string(), + valueName: z.string(), + valueRequired: z.boolean() + }) + })) + }) + ])), + "@context": z.string() + })) +}); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"googlemaps-zod.js","sourceRoot":"","sources":["../../src/lib/googlemaps-zod.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/search/dist-in/lib/googlemaps.d.ts b/packages/search/dist-in/lib/googlemaps.d.ts index f0bf1798..fc65f683 100644 --- a/packages/search/dist-in/lib/googlemaps.d.ts +++ b/packages/search/dist-in/lib/googlemaps.d.ts @@ -1,8 +1,8 @@ -import { zodSchema, zodSchemaEach, yargsOptions, yargsOptionsEach, IOptionsGoogleMaps, IOptionsGoogleMapsEach } from './googlemaps-zod.js'; -export { zodSchema, zodSchemaEach, yargsOptions, yargsOptionsEach, IOptionsGoogleMaps, IOptionsGoogleMapsEach }; +import { zodSchema, zodSchemaEach, yargsOptions, yargsOptionsEach, IOptionsGoogleMaps, IOptionsGoogleMapsInput, IOptionsGoogleMapsEach, IOptionsGoogleMapsEachInput, ResolveFlags } from './googlemaps-zod.js'; +export { zodSchema, zodSchemaEach, yargsOptions, yargsOptionsEach, IOptionsGoogleMaps, IOptionsGoogleMapsInput, IOptionsGoogleMapsEach, IOptionsGoogleMapsEachInput, ResolveFlags }; import type { GoogleParameters } from "serpapi"; import { IScaleserpSearch } from './types.js'; -import { LocalResult } from './map_types.js'; +import { GoogleMapResultInternal, type GoogleMapResult } from './google.js'; export declare enum SearchQueriesES { INJECTION = "inyecci\u00F3n de plastico" } @@ -20,8 +20,8 @@ export declare const defaultSearchParamsMapsES: (query: any, zoom: any, mixin?: hl: string; }; export declare const searchVendorSA: (query: string, location: string, key: string, opts: GoogleParameters) => Promise>; -export declare const searchGoogleMap: (query: string, key: string, opts: IOptionsGoogleMaps) => Promise; +export declare const searchGoogleMap: (query: string, key: string, opts: IOptionsGoogleMaps) => Promise; export declare const parse: (argv: IOptionsGoogleMaps) => IOptionsGoogleMaps; -export declare const googleMaps: (opts: IOptionsGoogleMaps) => Promise; +export declare const googleMaps: (opts: IOptionsGoogleMapsInput) => Promise; export declare const migrate: (opts: IOptionsGoogleMapsEach) => Promise; export declare const each: (opts: IOptionsGoogleMapsEach) => Promise; diff --git a/packages/search/dist-in/lib/googlemaps.js b/packages/search/dist-in/lib/googlemaps.js index 162210f0..9ed74503 100644 --- a/packages/search/dist-in/lib/googlemaps.js +++ b/packages/search/dist-in/lib/googlemaps.js @@ -3,14 +3,14 @@ import { CONFIG_DEFAULT, DEFAULT_ROOTS, pathInfo, filesEx } from '@polymech/comm import { cleanObjectStrings } from './googlemaps-utils.js'; import { parse as parseProfile } from '@polymech/commons/profile'; import { isFile, resolve, substitute } from '@polymech/commons'; -import { zodSchema, zodSchemaEach, yargsOptions, yargsOptionsEach, } from './googlemaps-zod.js'; +import { zodSchema, zodSchemaEach, yargsOptions, yargsOptionsEach, ResolveFlags, } from './googlemaps-zod.js'; import { parseCustomUrl, resolvePath } from './googlemaps-utils.js'; -export { zodSchema, zodSchemaEach, yargsOptions, yargsOptionsEach }; +export { zodSchema, zodSchemaEach, yargsOptions, yargsOptionsEach, ResolveFlags }; import { clone } from '../options.js'; import { sync as write } from '@polymech/fs/write'; import { sync as read } from '@polymech/fs/read'; import { sync as exists } from '@polymech/fs/exists'; -import { isArray, isObject, isString } from '@polymech/core/primitives'; +import { isArray, isObject } from '@polymech/core/primitives'; import pMap from 'p-map'; import { get_cached_object, set_cached_object } from '@polymech/cache/lib'; import { OSR_CACHE } from '@polymech/commons'; @@ -23,6 +23,7 @@ import { reverse, REVERSE_DEFAULT } from './geo.js'; import { writeReport } from '../lib/report_map.js'; import { geocode_forward } from './geo.js'; import { store as getStore } from '@polymech/registry'; +import axios from 'axios'; const MODULE_NAME = 'osr-search'; const queryExtras = ''; export var SearchQueriesES; @@ -155,7 +156,7 @@ export const searchGoogleMap = async (query, key, opts) => { results = results.filter((r) => r.geo.continent.toLowerCase() === opts.filterContinent.toLowerCase()); } if (opts.filterType) { - results = results.filter((r) => r.filterType === opts.filterType); + results = results.filter((r) => r.type === opts.filterType); } results = results.filter((r) => r.gps_coordinates); const beforeCached = results.length; @@ -209,7 +210,6 @@ const enrichResults = async (results, index, opts) => { } if (entry.meta && entry.website && !entry.email) { try { - logger.debug(`searching email for ${entry.website}`); return findEMail(SEARCH_AI_PROMPTS.GET_EMAIL, entry.website, opts, entry); } catch (e) { @@ -218,6 +218,30 @@ const enrichResults = async (results, index, opts) => { } }, { concurrency: 1 }); } + if (opts.resolve?.includes(ResolveFlags.PHOTOS)) { + await pMap(results, async (entry) => { + if (entry.google_media || !entry.data_id) { + return; + } + if (index[entry.title] && index[entry.title].google_media) { + entry.google_media = index[entry.title].google_media; + return; + } + try { + if (!entry.photos_link) + return; + const url = `${entry.photos_link}&api_key=${opts.api_key}`; + const response = await axios.get(url); + const photos = response.data; + if (photos) { + entry.google_media = photos; + } + } + catch (e) { + logger.error(`Error retrieving photo data for ${entry.title}`, e); + } + }, { concurrency: opts.concurrency }); + } return results; }; export const parse = (argv) => { @@ -232,7 +256,7 @@ export const parse = (argv) => { logger.warn('No serpapi key found in config!'); return; } - const opts = { + let opts = { query: argv.query, ...defaultSearchParamsMapsES(argv.query, argv.zoom), ...argv, @@ -242,29 +266,28 @@ export const parse = (argv) => { headless: argv.headless ? true : false, bigdata: { key: config.bigdata.key } }; - opts.source && isString(opts.source) && (opts.source = path.resolve(resolve(args.source, false))); - if (isString(opts.source)) { + opts = zodSchema().parse(opts); + /* + opts.source && isString(opts.source) && (opts.source = path.resolve(resolve(args.source, false))) + + if (opts.source && isString(opts.source)) { if (exists(opts.source)) { - opts.source = read(opts.source, 'json'); - } - else { - logger.error(`Source file ${args.source} not found : ${opts.source}`); - return; + opts.source = read(opts.source, 'json') + } else { + logger.error(`Source file ${args.source} not found : ${opts.source}`) + return } } + */ if (!opts.source && !opts.query) { logger.warn(`Invalid source and query`); return; } if (opts.index) { - opts.index = path.resolve(resolve(args.index, false)); + opts.index = path.resolve(resolve(opts.index, false)); } if (opts.store) { - opts.store = path.resolve(resolve(args.store, false)); - } - if (!opts.source) { - opts.source = {}; - opts.source[opts.category] = [opts.query]; + opts.store = path.resolve(resolve(opts.store, false)); } if (!opts.api_key) { logger.error('No Serpapi key found in config or options!'); @@ -300,9 +323,11 @@ export const googleMaps = async (opts) => { let ret = []; const search = async (query, category, opts) => { opts = clone(opts); - opts.dst = resolvePath(path.join(opts.cwd || '', opts.dst || ''), query, category, opts); - logger.debug(`output destination --dst "${opts.dst}"`); - if (opts.cache !== false && exists(opts.dst + '.json')) { + if (opts.dst) { + opts.dst = resolvePath(path.join(opts.cwd || '', opts.dst || ''), query, category, opts); + logger.debug(`output destination --dst "${opts.dst}"`); + } + if (opts.dst && opts.cache !== false && exists(opts.dst + '.json')) { const cachedPath = opts.dst + '.json'; const cached = read(cachedPath, 'json') || []; logger.debug(`Searching ${opts.query} with ${opts.searchFrom} :: returning cached ${cached.length}`); @@ -310,36 +335,33 @@ export const googleMaps = async (opts) => { return cached; } try { - logger.debug(`Searching ${opts.query} with ${opts.searchFrom}`); const sr = await searchGoogleMap(query, opts.api_key, { ...opts }); if (sr && sr.length && opts.dst) { - logger.debug('Writing', opts.dst); write(opts.dst + '.json', sr); writeReport(sr, opts.dst, opts); const parts = path.parse(opts.dst); write(path.join(parts.dir, parts.name + '_options.json'), cleanOptions(opts)); - // writeReport(sr, opts.dst.replace('.xlsx', '.md'), opts) } ret = [...ret, ...sr]; - logger.debug(`Searching ${opts.query} with ${opts.searchFrom}`); - return ret; + return sr; } catch (error) { logger.error('Error searching GoogleMaps : ' + error.message, error, error.stack); + return []; } }; - const all = await pMap(Object.keys(opts.source), (k) => { + // @todos : retry, ... + const all = (await pMap(Object.keys(opts.source), (k) => { return pMap(opts.source[k], (t) => { return search(t, k, opts); }, { - concurrency: 1 + concurrency: 1, }); }, { - concurrency: 1 - }); + concurrency: 1, + })).flat(2); if (opts.dst) { opts.dst = resolvePath(opts.dst, 'all', 'all', opts); - logger.debug(`final output destination --dst "${opts.dst}"`); let existingResults = []; if (exists(opts.dst + '.json')) { existingResults = read(opts.dst + '.json', 'json') || []; @@ -350,8 +372,7 @@ export const googleMaps = async (opts) => { map.set(obj.place_id, obj); } return map; - }, new Map()).values()) - .map(cleanObjectStrings) + }, new Map()).values()).map(cleanObjectStrings) .map((r) => { if (r.website && typeof r.website === 'string' && r.website.startsWith('/url?q=')) { try { @@ -459,4 +480,4 @@ export const each = async (opts) => { opts.log && write(path.resolve(resolve(opts.log)), all); return all; }; -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"googlemaps.js","sourceRoot":"","sources":["../../src/lib/googlemaps.ts"],"names":[],"mappings":"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"} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"googlemaps.js","sourceRoot":"","sources":["../../src/lib/googlemaps.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/search/dist-in/lib/html.d.ts b/packages/search/dist-in/lib/html.d.ts index 45b5c0a8..55b90625 100644 --- a/packages/search/dist-in/lib/html.d.ts +++ b/packages/search/dist-in/lib/html.d.ts @@ -1,15 +1,15 @@ import { AxiosRequestConfig } from "axios"; import { Browser } from 'puppeteer'; import * as puppeteer from 'puppeteer'; -import { LocalResult } from './map_types.js'; +import { LocalResult, LocationSiteMeta } from './map_types.js'; export declare const STATS_SUFFIX = "_stats.json"; export declare const SESSION_EVENTS_SUFFIX = "_session.json"; export declare const TRACE_SUFFIX = "_trace.json"; export declare var scope: Scope; export declare const extractEmail: (input: string) => string | null; -export declare const meta: (loc: LocalResult, options: any) => Promise; -export declare const isValidUrl: (url: any) => boolean; -export declare const parse: (url: string, config: AxiosRequestConfig, options: any) => Promise<{}>; +export declare const meta: (loc: LocalResult, options: any) => Promise; +export declare const isValidUrl: (url: string) => boolean; +export declare const parse: (url: string, config: AxiosRequestConfig | null, options: any) => Promise; export declare const getScope: (cliArgs?: any) => Scope; export declare function capture_responses(scope: Scope, page: puppeteer.Page): Promise; export declare class Scope { @@ -27,4 +27,3 @@ export declare class Scope { init(): Promise; } export declare const body: (url: string) => Promise; -export declare const contactUrl: (url: any) => Promise; diff --git a/packages/search/dist-in/lib/html.js b/packages/search/dist-in/lib/html.js index 504b98ff..861cfd96 100644 --- a/packages/search/dist-in/lib/html.js +++ b/packages/search/dist-in/lib/html.js @@ -1,12 +1,10 @@ import https from 'https'; import axios from "axios"; -import { parse as HTML } from "node-html-parser"; import * as cheerio from "cheerio"; import * as path from 'path'; import { URL } from 'url'; import * as puppeteer from 'puppeteer'; import { logger } from '../index.js'; -import { parse as retrieveMeta } from './html.js'; export const STATS_SUFFIX = '_stats.json'; export const SESSION_EVENTS_SUFFIX = '_session.json'; export const TRACE_SUFFIX = '_trace.json'; @@ -34,7 +32,7 @@ export const meta = async (loc, options) => { return; } try { - const _meta = await retrieveMeta(loc.website, null, options) || {}; + const _meta = await parse(loc.website, null, options) || {}; loc.meta = _meta; loc.instagram = _meta.instagram; loc.facebook = _meta.facebook; @@ -42,6 +40,7 @@ export const meta = async (loc, options) => { loc.linkedin = _meta.linkedin; loc.twitter = _meta.twitter; loc.email = (_meta.allLinks || []).map((l) => extractEmail(l)).filter((e) => e !== null)[0]; + return _meta; } catch (error) { logger.error('Error retrieving meta data : ' + loc.website, error.message); @@ -58,9 +57,8 @@ export const isValidUrl = (url) => { return false; } }; -const readMetaTags = (el, name) => { - var prop = el.getAttribute('name') || el.getAttribute('property'); - return prop == name ? el.getAttribute('content') : null; +const readMetaTags = ($, name) => { + return $(`meta[name="${name}"]`).attr('content') || $(`meta[property="${name}"]`).attr('content') || null; }; export const parse = async (url, config, options) => { if (!/(^http(s?):\/\/[^\s$.?#].[^\s]*)/i.test(url)) @@ -75,47 +73,46 @@ export const parse = async (url, config, options) => { }, timeout: 10000 }); - const $ = HTML(data); + const $ = cheerio.load(data); const og = {}; const meta = {}; const images = []; const links = []; let allLinks = []; - const title = $.querySelector('title'); + const title = $('title').text(); if (title) - meta.title = title.text; - const canonical = $.querySelector('link[rel=canonical]'); + meta.title = title; + const canonical = $('link[rel=canonical]').attr('href'); if (canonical) { - meta.url = canonical.getAttribute('href'); + meta.url = canonical; } - const metas = $.querySelectorAll('meta'); - for (let i = 0; i < metas.length; i++) { - const el = metas[i]; - // const prop = el.getAttribute('property') || el.getAttribute('name'); - ['title', 'description', 'image'].forEach(s => { - const val = readMetaTags(el, s); - if (val) - meta[s] = val; - }); - ['og:title', 'og:description', 'og:image', 'og:url', 'og:site_name', 'og:type'].forEach(s => { - const val = readMetaTags(el, s); - if (val) - og[s.split(':')[1]] = val; - }); - } - $.querySelectorAll('img').forEach(el => { - let src = el.getAttribute('src'); + ['title', 'description', 'image'].forEach(s => { + const val = readMetaTags($, s); + if (val) + meta[s] = val; + }); + ['og:title', 'og:description', 'og:image', 'og:url', 'og:site_name', 'og:type'].forEach(s => { + const val = readMetaTags($, s); + if (val) + og[s.split(':')[1]] = val; + }); + $('img').each((i, el) => { + let src = $(el).attr('src'); if (src) { - src = new URL(src, url).href; - images.push({ src }); + try { + src = new URL(src, url).href; + images.push({ src }); + } + catch (e) { + // ignore invalid urls + } } }); - const _$ = cheerio.load(data); // Array to store JSON-LD data const jsonLdArray = []; // Select all