tablefacts 0.1.0

package/types/menu/cluvi/config.d.mts

@@ -0,0 +1,13 @@
+declare const _default: {
+    url: string;
+    categories: {
+        slug: string;
+        name: string;
+        from: string[];
+    }[];
+    sections: {
+        "Cócteles Autor Cannario": string;
+        Mocktails: string;
+    };
+};
+export default _default;

package/types/menu/cluvi/extract.d.mts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/types/menu/cluvi/import.d.mts

@@ -0,0 +1,35 @@
+/**
+ * Reads and normalizes the menu: `{ menu, notes, title }`, ready for importMenu.
+ * `config` is the restaurant-specific part (see config.mjs); the default is that file's.
+ */
+export declare function fetchCluviMenu({ url, service, lang, config }?: {
+    config?: {
+        url: string;
+        categories: {
+            slug: string;
+            name: string;
+            from: string[];
+        }[];
+        sections: {
+            "Cócteles Autor Cannario": string;
+            Mocktails: string;
+        };
+    } | undefined;
+}): Promise<{
+    menu: {
+        slug: any;
+        name: any;
+        sections: {
+            name: any;
+            products: any;
+        }[];
+    }[];
+    notes: string[];
+    title: string;
+}>;
+/**
+ * Reads the menu from Cluvi and imports it. Takes importMenu's options too.
+ * @param {import('../../lib/types.mjs').ImportCluviOptions} [options]
+ * @returns {Promise<import('../../lib/types.mjs').ImportResult>}
+ */
+export declare function importCluvi({ url, service, lang, config, ...importOptions }?: import('../../lib/types.mjs').ImportCluviOptions): Promise<import('../../lib/types.mjs').ImportResult>;

package/types/menu/cluvi/source.d.mts

@@ -0,0 +1,37 @@
+/** https://<restaurant>.cluvi.co/<supplier>/maincategories gives "<supplier>". */
+export declare function supplierSlug(menuUrl: any): string;
+/**
+ * `service` picks which of the restaurant's menus to read. `on_table` is the
+ * digital menu guests open from the table QR code and is the complete one:
+ * `delivery` and `take_away` only list what the restaurant sells that way.
+ */
+export declare function fetchCluvi({ url, service, lang }: {
+    lang?: string | undefined;
+    service?: string | undefined;
+    url: any;
+}): Promise<{
+    supplier: any;
+    raw: any;
+    service: string;
+}>;
+/**
+ * Cluvi's response to the shape lib/menu.mjs describes. Main categories are
+ * folded into the categories of `config.categories`, subcategories become
+ * sections, and products keep the order Cluvi shows them in (their `order`
+ * field, not their position in the subcategory's product_ids).
+ */
+export declare function normalizeCluvi({ supplier, raw }: {
+    raw: any;
+    supplier: any;
+}, config: any): {
+    menu: {
+        slug: any;
+        name: any;
+        sections: {
+            name: any;
+            products: any;
+        }[];
+    }[];
+    notes: string[];
+    currency: string;
+};

package/types/menu/index.d.mts

@@ -0,0 +1,6 @@
+export { importMenu } from "./lib/import.mjs";
+export { importCluvi } from "./cluvi/import.mjs";
+export { importImageMenu, listMenuImages } from "./raw/import.mjs";
+export { cleanText, countMenu, sectionName, slugify, validateMenu } from "./lib/menu.mjs";
+export { normalizePages, parsePrice } from "./raw/normalize.mjs";
+export { defaultProvider, providers } from "./raw/vision.mjs";

package/types/menu/lib/db.d.mts

@@ -0,0 +1,23 @@
+/** Opens the connection. `label` names the target without the credentials. */
+export declare function connect(url: any, { env }?: {}): Promise<{
+    client: any;
+    label: string;
+}>;
+/** What an import would replace: the categories it writes, or the whole menu. */
+export declare function inspect(client: any, menu: any, { replaceAll }?: {
+    replaceAll?: boolean | undefined;
+}): Promise<any>;
+/**
+ * Replaces the menu in one transaction, so readers see the old menu or the new
+ * one and a failure changes nothing. By default only the categories in `menu`
+ * are replaced (deleting a category cascades to its sections and products);
+ * `replaceAll` empties the menu first. Ids are generated here so the rows can
+ * be inserted in bulk, a column at a time.
+ */
+export declare function replaceMenu(client: any, menu: any, { replaceAll }?: {
+    replaceAll?: boolean | undefined;
+}): Promise<{
+    categories: any;
+    sections: any;
+    products: any;
+}>;

package/types/menu/lib/import.d.mts

@@ -0,0 +1,11 @@
+/** Things the site needs that this menu does not give it, read from the template's own files. */
+export declare function templateHints(menu: any, { projectDir }?: {}): Promise<string[]>;
+/**
+ * Checks `menu` (the shape of lib/menu.mjs) and writes it to the database.
+ * `notes` are what the source wants the user to know; `title` heads the log.
+ * Resolves to `{ totals, notes, written, dryRun, database }`, `database` being
+ * `{ label, current }` once it was inspected and null when it was not reached.
+ * @param {import('../../lib/types.mjs').ImportMenuOptions} options
+ * @returns {Promise<import('../../lib/types.mjs').ImportResult>}
+ */
+export declare function importMenu({ menu, notes, title, dryRun, json, replaceAll, force, databaseUrl, env, projectDir, log: logOption, }?: import('../../lib/types.mjs').ImportMenuOptions): Promise<import('../../lib/types.mjs').ImportResult>;

package/types/menu/lib/menu.d.mts

@@ -0,0 +1,24 @@
+declare const squash: (text: any) => string;
+/** Collapses runs of whitespace (Cluvi labels carry stray spaces). */
+export declare const cleanText: typeof squash;
+/** Lowercase, accent-free key, to compare labels typed by different people. */
+export declare const matchKey: (text: any) => string;
+export declare const slugify: (text: any) => string;
+export declare const sectionName: (text: any) => string;
+/** Rich-text descriptions (<p>, <br>, <span style>) to plain text, one line per paragraph. */
+export declare function htmlToText(html: any): string | null;
+/** An invalid code would make Intl.NumberFormat throw in the site's formatPrice. */
+export declare const isCurrency: (code: any) => boolean;
+/**
+ * Totals of a menu.
+ * @param {import('../../lib/types.mjs').Menu} menu
+ * @returns {import('../../lib/types.mjs').MenuTotals}
+ */
+export declare function countMenu(menu: import('../../lib/types.mjs').Menu): import('../../lib/types.mjs').MenuTotals;
+/**
+ * Throws a TablefactsError (EFAILED) on anything the database or the site could not take, naming the culprit.
+ * @param {import('../../lib/types.mjs').Menu} menu
+ * @returns {void}
+ */
+export declare function validateMenu(menu: import('../../lib/types.mjs').Menu): void;
+export {};

package/types/menu/lib/run.d.mts

@@ -0,0 +1,27 @@
+/** The option names the menu library uses in its messages, as the flags the CLI shows. */
+export declare const menuFlags: {
+    only: string;
+    provider: string;
+    model: string;
+    minWidth: string;
+    replaceAll: string;
+    force: string;
+    dryRun: string;
+};
+/** A library message with option names turned into flags. */
+export declare const flagText: (message: any) => string;
+/**
+ * The CLI's logger: info and warn lines (progress, notes, "left untouched") go to stdout as
+ * they always did, errors to stderr, and option names in the text become flags.
+ */
+export declare const cliLog: (message: any, level?: string) => void;
+/**
+ * `fetchMenu({ values, positionals })` returns `{ menu, notes, title }`: the
+ * menu in the shape of lib/menu.mjs, what the source wants the user to know,
+ * and a heading. `options` are the source's own flags, in util.parseArgs form.
+ */
+export declare function runImport({ usage, options, fetchMenu }: {
+    fetchMenu: any;
+    options?: {} | undefined;
+    usage: any;
+}): Promise<void>;

package/types/menu/raw/config.d.mts

@@ -0,0 +1,18 @@
+declare const _default: {
+    url: string;
+    currency: string;
+    thousands: string;
+    decimal: string;
+    scale: number;
+    categories: {
+        slug: string;
+        name: string;
+        groups: string[];
+    }[];
+    placeIn: {};
+    sections: {
+        "Cócteles de Autor": string;
+    };
+    skipSections: never[];
+};
+export default _default;

package/types/menu/raw/extract.d.mts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/types/menu/raw/import.d.mts

@@ -0,0 +1,64 @@
+/** Every image found, and the numbered ones `only` selects. `config` defaults to config.mjs. */
+export declare function findPages({ urls, only, minWidth, config }?: {
+    config?: {
+        url: string;
+        currency: string;
+        thousands: string;
+        decimal: string;
+        scale: number;
+        categories: {
+            slug: string;
+            name: string;
+            groups: string[];
+        }[];
+        placeIn: {};
+        sections: {
+            "Cócteles de Autor": string;
+        };
+        skipSections: never[];
+    } | undefined;
+    minWidth?: number | undefined;
+    urls?: never[] | undefined;
+}): Promise<{
+    pages: any[];
+    chosen: any[];
+}>;
+/**
+ * The pictures the CLI's `--list` prints, numbered. `only` narrows them.
+ * @param {import('../../lib/types.mjs').ListMenuImagesOptions} [options]
+ * @returns {Promise<import('../../lib/types.mjs').MenuImage[]>}
+ */
+export declare function listMenuImages(options?: import('../../lib/types.mjs').ListMenuImagesOptions): Promise<import('../../lib/types.mjs').MenuImage[]>;
+/** Reads the pages and normalizes them: `{ menu, notes, title }`, ready for importMenu. */
+export declare function fetchImageMenu({ urls, only, provider, model, minWidth, refresh, apiKey, env, projectDir, config, log: logOption }?: {
+    config?: {
+        url: string;
+        currency: string;
+        thousands: string;
+        decimal: string;
+        scale: number;
+        categories: {
+            slug: string;
+            name: string;
+            groups: string[];
+        }[];
+        placeIn: {};
+        sections: {
+            "Cócteles de Autor": string;
+        };
+        skipSections: never[];
+    } | undefined;
+    minWidth?: number | undefined;
+    refresh?: boolean | undefined;
+    urls?: never[] | undefined;
+}): Promise<{
+    menu: import("../../lib/types.mjs").Menu;
+    notes: string[];
+    title: string;
+}>;
+/**
+ * Reads the menu from pictures with a vision model and imports it. Takes importMenu's options too.
+ * @param {import('../../lib/types.mjs').ImportImageMenuOptions} [options]
+ * @returns {Promise<import('../../lib/types.mjs').ImportResult>}
+ */
+export declare function importImageMenu({ urls, only, provider, model, minWidth, refresh, apiKey, env, config, ...importOptions }?: import('../../lib/types.mjs').ImportImageMenuOptions): Promise<import('../../lib/types.mjs').ImportResult>;

package/types/menu/raw/normalize.d.mts

@@ -0,0 +1,29 @@
+/**
+ * "$95.000" to 95000. `thousands` and `decimal` are the separators the menu
+ * prints (Colombia: "." and ","); `scale` multiplies the result for menus that
+ * print "95" meaning 95.000. Returns null for text with no number.
+ * @param {string} text
+ * @param {import('../../lib/types.mjs').PriceFormat} [format]
+ * @returns {number | null}
+ */
+export declare function parsePrice(text: string, { thousands, decimal, scale }?: import('../../lib/types.mjs').PriceFormat): number | null;
+/**
+ * `pages` is the transcription of each page, in page order. A section with no
+ * title continues the section before it (a list that runs onto the next page),
+ * and sections with the same title are merged. Each section is placed in the
+ * category of `config.categories` that lists its group (food, drink), unless
+ * `config.placeIn` names it. An item with several priced columns becomes one
+ * product per column, "Name (Botella)", because a product has one price.
+ * @param {{ number?: number, notes?: string[], sections?: any[] }[]} pages transcriptions, one per page
+ * @param {import('../../lib/types.mjs').RawConfig} config
+ * @returns {{ menu: import('../../lib/types.mjs').Menu, notes: string[], currency: string }}
+ */
+export declare function normalizePages(pages: {
+    number?: number;
+    notes?: string[];
+    sections?: any[];
+}[], config: import('../../lib/types.mjs').RawConfig): {
+    menu: import('../../lib/types.mjs').Menu;
+    notes: string[];
+    currency: string;
+};

package/types/menu/raw/source.d.mts

@@ -0,0 +1,19 @@
+/**
+ * The picture URLs of a page, in document order. Lazy-loaders keep the real
+ * address in data-orig-src / data-src and put a placeholder in src, so those
+ * come first. Images declaring a width under `minWidth` (logos, icons) and
+ * anything that is not a JPG, PNG or WebP (SVG logos) are skipped.
+ */
+export declare function findImages(html: any, pageUrl: any, { minWidth }?: {
+    minWidth?: number | undefined;
+}): any[];
+/** Each argument is a page to scan or a direct image URL. */
+export declare function discoverPages(inputs: any, options: any): Promise<any[]>;
+export declare const pageId: (url: any) => string;
+/** Downloads one page image into the cache (once) and returns where it is and what it is. */
+export declare function downloadPage(page: any, host: any, { projectDir }?: {}): Promise<{
+    id: string;
+    dir: string;
+    file: string;
+    mediaType: string;
+}>;

package/types/menu/raw/vision.d.mts

@@ -0,0 +1,13 @@
+/** @type {Record<string, import('../../lib/types.mjs').VisionProvider>} */
+export declare const providers: Record<string, import('../../lib/types.mjs').VisionProvider>;
+export declare const defaultProvider = "anthropic";
+/** `file` is a downloaded picture; returns `{ sections, notes }` as the schema above describes. */
+export declare function readPage({ file, mediaType }: {
+    file: any;
+    mediaType: any;
+}, { provider, model, apiKey, env }?: {
+    provider?: string | undefined;
+}): Promise<{
+    sections: any;
+    notes: any;
+}>;

package/types/research/index.d.mts

@@ -0,0 +1,9 @@
+/**
+ * Researches a restaurant from public sources and writes profile.json, report.md and
+ * setup-answers.txt. Silent unless `log` is given; a source that fails becomes a note in the
+ * report, not an error. Throws a TablefactsError with code 'EUSAGE' (and `option` 'name') when
+ * `name` is missing.
+ * @param {import('../lib/types.mjs').ResearchOptions} options
+ * @returns {Promise<import('../lib/types.mjs').ResearchResult>}
+ */
+export declare function research(options?: import('../lib/types.mjs').ResearchOptions): Promise<import('../lib/types.mjs').ResearchResult>;

package/types/research/lib/google.d.mts

@@ -0,0 +1,12 @@
+/** Returns { place, candidates }: `place` is the first result whose name matches, or null. */
+export declare function searchGoogle({ name, location, country, key }: {
+    country: any;
+    key: any;
+    location: any;
+    name: any;
+}): Promise<{
+    place: any;
+    candidates: any;
+}>;
+/** Downloads up to `count` photos into `dir`, returns what was saved. The key stays out of the result. */
+export declare function downloadPhotos(place: any, key: any, count: any, save: any): Promise<any[]>;

package/types/research/lib/hours.d.mts

@@ -0,0 +1,22 @@
+/** Google `regularOpeningHours.periods` (day 0 = Sunday). */
+export declare function fromGoogle(periods?: any[]): {
+    week: string[][][];
+} | null;
+/** OpenStreetMap / schema.org `openingHours` syntax: "Mo-Th 12:00-22:00; Fr,Sa 12:00-00:00; Su off". */
+export declare function fromOsm(text: any): {
+    week: string[][][];
+    partial?: undefined;
+} | {
+    week: never[][];
+    partial: boolean;
+} | null;
+/** schema.org `openingHoursSpecification` entries. */
+export declare function fromSpec(specs?: any[]): {
+    week: never[][];
+} | null;
+export declare const weekSignature: (week: any) => any;
+/** Rows for `visit.hoursRows`: { label, value }, matching the template's wording. */
+export declare function formatRows(week: any, lang: any): {
+    label: any;
+    value: any;
+}[];

package/types/research/lib/merge.d.mts

@@ -0,0 +1,87 @@
+export declare function buildProfile({ query, google, osm, site, hub, instagram, tripadvisor }: {
+    google: any;
+    hub: any;
+    instagram: any;
+    osm: any;
+    query: any;
+    site: any;
+    tripadvisor: any;
+}): {
+    query: any;
+    generatedAt: string;
+    warnings: string[];
+    fields: {
+        name: any;
+        street: any;
+        locality: any;
+        region: any;
+        country: any;
+        coordinates: any;
+        phone: any;
+        email: any;
+        instagram: any;
+        facebook: any;
+        tiktok: any;
+        tripadvisor: any;
+        website: any;
+        reserveUrl: any;
+        priceRange: any;
+        mapsUrl: any;
+        descriptor: any;
+    };
+    hours: {
+        source: string;
+        week: any;
+        rows: {
+            es: {
+                label: any;
+                value: any;
+            }[];
+            en: {
+                label: any;
+                value: any;
+            }[];
+        };
+        confidence: string;
+        conflicts: {
+            source: string;
+            rows: {
+                label: any;
+                value: any;
+            }[];
+        }[];
+    } | null;
+    textHours: any[];
+    links: {
+        menu: any[];
+        delivery: any[];
+        reserve: any[];
+        waze: any[];
+        hubs: any[];
+    };
+    ratings: any[];
+    images: {
+        logos: any[];
+        site: any;
+        hub: any;
+        googlePhotos: any;
+        instagramImage: any;
+        themeColor: any;
+    };
+    copySources: {
+        googleSummary: any;
+        siteDescription: any;
+        instagramBio: any;
+        tripadvisor: any;
+        headings: any;
+        paragraphs: any;
+    };
+    social: {
+        instagram: {
+            handle: any;
+            followers: any;
+            posts: any;
+            blocked: any;
+        } | null;
+    };
+};

package/types/research/lib/osm.d.mts

@@ -0,0 +1,36 @@
+export declare function searchOsm({ name, location, country }: {
+    country: any;
+    location: any;
+    name: any;
+}): Promise<{
+    place: {
+        source: string;
+        name: any;
+        street: string;
+        locality: any;
+        region: any;
+        country: any;
+        postcode: any;
+        coords: {
+            lat: number;
+            lng: number;
+        };
+        phone: any;
+        whatsapp: any;
+        email: any;
+        website: any;
+        instagram: any;
+        facebook: any;
+        cuisines: any;
+        hours: {
+            week: string[][][];
+            partial?: undefined;
+        } | {
+            week: never[][];
+            partial: boolean;
+        } | null;
+        hoursRaw: any;
+        osmUrl: string;
+    } | null;
+    candidates: any;
+}>;

package/types/research/lib/report.d.mts

@@ -0,0 +1,6 @@
+export declare function renderReport(p: any, { notes, photos }: {
+    notes: any;
+    photos: any;
+}): string;
+/** One line per prompt of `data/scripts/setup.mjs`, in its order. Blank keeps the current value. */
+export declare function setupAnswers(p: any): string;

package/types/research/lib/social.d.mts

@@ -0,0 +1,118 @@
+/**
+ * Public Instagram profile metadata. Without a login the page only exposes the
+ * share card: "1,234 Followers, 56 Following, 789 Posts - Name (@handle) on
+ * Instagram: "bio"". The bio often carries the phone, the area and a hub link.
+ */
+export declare function readInstagram(handle: any): Promise<{
+    handle: any;
+    url: string;
+    blocked: any;
+    displayName?: undefined;
+    followers?: undefined;
+    posts?: undefined;
+    bio?: undefined;
+    phones?: undefined;
+    links?: undefined;
+    image?: undefined;
+} | {
+    blocked?: undefined;
+    handle: any;
+    url: string;
+    displayName: any;
+    followers: any;
+    posts: any;
+    bio: any;
+    phones: any[];
+    links: any;
+    image: any;
+}>;
+/** TripAdvisor: schema.org JSON-LD when the page loads; DataDome often blocks it. */
+export declare function readTripadvisor(url: any, { browser }?: {}): Promise<{
+    url: any;
+    blocked: string;
+    jsonld?: undefined;
+    description?: undefined;
+    hoursText?: undefined;
+    images?: undefined;
+} | {
+    blocked?: undefined;
+    url: any;
+    jsonld: {
+        name: any;
+        telephone: any;
+        email: any;
+        priceRange: any;
+        cuisines: string[];
+        address: {
+            street: any;
+            locality: any;
+            region: any;
+            postcode: any;
+            country: any;
+        };
+        geo: {
+            lat: number;
+            lng: number;
+        } | null;
+        sameAs: string[];
+        logo: any;
+        rating: {
+            value: number;
+            count: number | null;
+        } | null;
+        hours: {
+            week: string[][][];
+            partial?: undefined;
+        } | {
+            week: never[][];
+        } | null;
+    } | null;
+    description: any;
+    hoursText: any;
+    images: any[];
+}>;
+/** A link-in-bio hub (Linktree, Beacons, bio.link): its links, classified like a website's. */
+export declare function readHub(url: any, { browser }?: {}): Promise<{
+    links?: undefined;
+    images?: undefined;
+    url: any;
+    blocked: string;
+    title?: undefined;
+    meta?: undefined;
+    anchors?: undefined;
+    logos?: undefined;
+} | {
+    blocked?: undefined;
+    url: any;
+    title: any;
+    meta: {
+        siteName: any;
+        title: any;
+        description: any;
+        themeColor: any;
+    };
+    links: {
+        tel: never[];
+        mail: never[];
+        whatsapp: never[];
+        reserve: never[];
+        menu: never[];
+        delivery: never[];
+        maps: never[];
+        waze: never[];
+        facebook: never[];
+        tiktok: never[];
+        tripadvisor: never[];
+        hubs: never[];
+        instagram: never[];
+    };
+    anchors: {
+        href: string | null;
+        text: any;
+    }[];
+    logos: {
+        url: string | null;
+        kind: any;
+    }[];
+    images: any[];
+}>;