entasis 0.13.4 → 0.13.6

package/dist/components/Address/address.google.js

@@ -0,0 +1,184 @@
+import { composeStreetLine } from './address.js';
+const DEFAULT_ENDPOINT = 'https://places.googleapis.com/v1';
+const DETAILS_FIELD_MASK = 'id,formattedAddress,addressComponents,location';
+const ADDRESS_TYPES = ['street_address', 'premise', 'subpremise', 'route'];
+/** The first component of `place` carrying one of `types`, in the order of `types`. */
+const component = (place, ...types) => {
+    for (const type of types) {
+        const found = place.addressComponents?.find((entry) => entry.types?.includes(type));
+        if (found)
+            return found;
+    }
+    return undefined;
+};
+/**
+ * An `Address` from a Google Place: the street line in the country's order, the postal town
+ * or the nearest locality as the city, the first administrative level as the region (its short
+ * form in the United States, Canada and Australia, where it is written "CA" or "NSW").
+ */
+export function parseGooglePlace(place) {
+    const countryCode = component(place, 'country')?.shortText?.toUpperCase() ?? null;
+    const streetNumber = component(place, 'street_number')?.longText ?? null;
+    const street = component(place, 'route')?.longText ?? null;
+    const region = component(place, 'administrative_area_level_1');
+    const shortRegion = countryCode === 'US' || countryCode === 'CA' || countryCode === 'AU';
+    const premise = component(place, 'subpremise', 'premise')?.longText ?? null;
+    const latitude = place.location?.latitude;
+    const longitude = place.location?.longitude;
+    return {
+        line1: composeStreetLine(streetNumber, street, countryCode) ?? premise,
+        line2: composeStreetLine(streetNumber, street, countryCode) ? premise : null,
+        postalCode: component(place, 'postal_code')?.longText ?? null,
+        city: component(place, 'locality', 'postal_town', 'sublocality_level_1', 'sublocality', 'administrative_area_level_3', 'administrative_area_level_2')?.longText ?? null,
+        region: (shortRegion ? region?.shortText : region?.longText) ?? null,
+        country: component(place, 'country')?.longText ?? null,
+        countryCode,
+        streetNumber,
+        street,
+        formatted: place.formattedAddress ?? null,
+        placeId: place.id ?? null,
+        location: typeof latitude === 'number' && typeof longitude === 'number'
+            ? { lat: latitude, lng: longitude }
+            : null
+    };
+}
+/** A Places request that failed, with its HTTP status. */
+export class GooglePlacesError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'GooglePlacesError';
+    }
+}
+async function failure(response) {
+    let message = `Google Places request failed (${response.status})`;
+    try {
+        const body = (await response.json());
+        if (body.error?.message)
+            message = `Google Places: ${body.error.message}`;
+    }
+    catch {
+        // Not JSON: keep the status.
+    }
+    return new GooglePlacesError(response.status, message);
+}
+/**
+ * An `AddressProvider` backed by Google Places (Places API "New"). Pass a browser `apiKey`, or an
+ * `endpoint` on your server that adds the key, so it never reaches the page.
+ */
+export function createGooglePlacesProvider(options = {}) {
+    const endpoint = (options.endpoint ?? DEFAULT_ENDPOINT).replace(/\/$/, '');
+    const types = options.types ?? ADDRESS_TYPES;
+    const request = (input, init) => {
+        const headers = new Headers(init.headers);
+        if (options.apiKey)
+            headers.set('X-Goog-Api-Key', options.apiKey);
+        return (options.fetch ?? fetch)(`${endpoint}${input}`, { ...init, headers });
+    };
+    return {
+        async search(query, { signal, session, language, countries }) {
+            const input = query.trim();
+            if (!input)
+                return [];
+            const response = await request('/places:autocomplete', {
+                method: 'POST',
+                signal,
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    input,
+                    sessionToken: session,
+                    languageCode: language ?? options.language,
+                    regionCode: options.region,
+                    includedRegionCodes: countries?.length
+                        ? countries.map((code) => code.toLowerCase())
+                        : undefined,
+                    includedPrimaryTypes: types.length ? types : undefined
+                })
+            });
+            if (!response.ok)
+                throw await failure(response);
+            const body = (await response.json());
+            return (body.suggestions ?? []).flatMap((suggestion) => {
+                const prediction = suggestion.placePrediction;
+                if (!prediction?.placeId)
+                    return [];
+                const main = prediction.structuredFormat?.mainText?.text;
+                return [
+                    {
+                        id: prediction.placeId,
+                        label: main ?? prediction.text?.text ?? '',
+                        description: main ? prediction.structuredFormat?.secondaryText?.text : undefined
+                    }
+                ];
+            });
+        },
+        async resolve(id, { signal, session, language }) {
+            const params = new URLSearchParams({ sessionToken: session });
+            const languageCode = language ?? options.language;
+            if (languageCode)
+                params.set('languageCode', languageCode);
+            if (options.region)
+                params.set('regionCode', options.region);
+            const response = await request(`/places/${encodeURIComponent(id)}?${params}`, {
+                method: 'GET',
+                signal,
+                headers: { 'X-Goog-FieldMask': DETAILS_FIELD_MASK }
+            });
+            if (!response.ok)
+                throw await failure(response);
+            return parseGooglePlace((await response.json()));
+        }
+    };
+}
+const AUTOCOMPLETE_PATH = /\/places:autocomplete$/;
+const PLACE_PATH = /\/places\/([\w-]+)$/;
+/**
+ * Server handlers for the route `AddressInput` searches through by default
+ * (`/api/places/[...path]`): they forward the two Places calls to Google with the server's key.
+ * Nothing else passes: any other path or method answers 404, so the route is not an open proxy.
+ *
+ * ```ts
+ * // src/routes/api/places/[...path]/+server.ts
+ * import { createGooglePlacesProxy } from './index.ts';
+ * export const { GET, POST } = createGooglePlacesProxy({ apiKey: GOOGLE_PLACE_API_KEY });
+ * ```
+ */
+export function createGooglePlacesProxy({ apiKey, fetch: fetchImpl }) {
+    const notFound = () => new Response('Not found', { status: 404 });
+    const forward = async (path, init, search = '') => {
+        if (!apiKey)
+            return notFound();
+        const headers = new Headers(init.headers);
+        headers.set('X-Goog-Api-Key', apiKey);
+        const response = await (fetchImpl ?? fetch)(`${DEFAULT_ENDPOINT}${path}${search}`, {
+            ...init,
+            headers
+        });
+        return new Response(response.body, {
+            status: response.status,
+            headers: { 'Content-Type': response.headers.get('Content-Type') ?? 'application/json' }
+        });
+    };
+    return {
+        POST: async ({ request }) => {
+            if (!AUTOCOMPLETE_PATH.test(new URL(request.url).pathname))
+                return notFound();
+            return forward('/places:autocomplete', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: await request.text()
+            });
+        },
+        GET: async ({ request }) => {
+            const url = new URL(request.url);
+            const id = PLACE_PATH.exec(url.pathname)?.[1];
+            if (!id)
+                return notFound();
+            return forward(`/places/${id}`, {
+                method: 'GET',
+                headers: { 'X-Goog-FieldMask': DETAILS_FIELD_MASK }
+            }, url.search);
+        }
+    };
+}

package/dist/components/Address/address.js

@@ -0,0 +1,109 @@
+/**
+ * A postal address as entasis stores, edits and displays it, the order its lines take in each
+ * country, and the provider contract an address search plugs into.
+ */
+/** Every address part, in the order a form usually asks for them. */
+export const ADDRESS_FIELDS = [
+    'line1',
+    'line2',
+    'postalCode',
+    'city',
+    'region',
+    'country'
+];
+const text = (value) => (value ?? '').trim();
+/** True when no part a person reads (lines, postal code, city, region, country) is filled. */
+export function isAddressEmpty(address) {
+    if (!address)
+        return true;
+    return ADDRESS_FIELDS.every((field) => text(address[field]) === '');
+}
+// Countries that write the street number after the street name ("Hauptstraße 12").
+const NUMBER_AFTER_STREET = new Set([
+    'AR', 'AT', 'BA', 'BE', 'BG', 'BO', 'BR', 'CH', 'CL', 'CO', 'CR', 'CZ', 'DE', 'DK', 'EE', 'ES',
+    'FI', 'GR', 'HR', 'HU', 'IS', 'IT', 'LI', 'LT', 'LV', 'MX', 'NL', 'NO', 'PE', 'PL', 'PT', 'RO',
+    'RS', 'SE', 'SI', 'SK', 'TR', 'UY', 'VE'
+]); // prettier-ignore
+/** The street line for a number and a street, in the order `countryCode` writes them. */
+export function composeStreetLine(streetNumber, street, countryCode) {
+    const number = text(streetNumber);
+    const name = text(street);
+    if (!number || !name)
+        return name || number || null;
+    return NUMBER_AFTER_STREET.has((countryCode ?? '').toUpperCase())
+        ? `${name} ${number}`
+        : `${number} ${name}`;
+}
+// Countries whose locality line reads "City, REGION POSTAL" (North America, Australia).
+const CITY_REGION_POSTAL = new Set(['US', 'CA', 'AU', 'PR', 'GU', 'VI', 'AS', 'MP']);
+// Countries that put the postal code on its own line after the city (UK and Ireland).
+const POSTAL_OWN_LINE = new Set(['GB', 'IE', 'IM', 'JE', 'GG']);
+/** The country name for `address`: its own `country`, or `countryCode` written in `locale`. */
+export function addressCountryName(address, locale) {
+    const name = text(address.country);
+    if (name)
+        return name;
+    const code = text(address.countryCode).toUpperCase();
+    return code ? countryName(code, locale) : '';
+}
+/**
+ * The lines of an address as the country writes them: street lines, then the locality line
+ * (postal code and city, in the country's order, with the region where it belongs), then the
+ * country. Empty parts and empty lines are left out.
+ */
+export function formatAddress(address, { fields = ADDRESS_FIELDS, locale } = {}) {
+    if (!address)
+        return [];
+    const has = new Set(fields);
+    const part = (field) => (has.has(field) ? text(address[field]) : '');
+    const code = text(address.countryCode).toUpperCase();
+    const postal = part('postalCode');
+    const city = part('city');
+    const region = part('region');
+    const lines = [part('line1'), part('line2')];
+    if (CITY_REGION_POSTAL.has(code)) {
+        const regionPostal = [region, postal].filter(Boolean).join(' ');
+        lines.push([city, regionPostal].filter(Boolean).join(', '));
+    }
+    else if (POSTAL_OWN_LINE.has(code)) {
+        lines.push(city, region, postal);
+    }
+    else {
+        lines.push([postal, city].filter(Boolean).join(' '), region);
+    }
+    if (has.has('country'))
+        lines.push(addressCountryName(address, locale));
+    return lines.filter(Boolean);
+}
+/** The address on one line, its lines joined by ", ". */
+export const formatAddressLine = (address, options) => formatAddress(address, options).join(', ');
+/** ISO 3166-1 alpha-2 codes of every country and territory a postal address can be in. */
+export const COUNTRY_CODES = ('AD AE AF AG AI AL AM AO AQ AR AS AT AU AW AX AZ BA BB BD BE BF BG BH BI BJ BL BM BN BO BQ BR ' +
+    'BS BT BV BW BY BZ CA CC CD CF CG CH CI CK CL CM CN CO CR CU CV CW CX CY CZ DE DJ DK DM DO DZ ' +
+    'EC EE EG EH ER ES ET FI FJ FK FM FO FR GA GB GD GE GF GG GH GI GL GM GN GP GQ GR GS GT GU GW ' +
+    'GY HK HM HN HR HT HU ID IE IL IM IN IO IQ IR IS IT JE JM JO JP KE KG KH KI KM KN KP KR KW KY ' +
+    'KZ LA LB LC LI LK LR LS LT LU LV LY MA MC MD ME MF MG MH MK ML MM MN MO MP MQ MR MS MT MU MV ' +
+    'MW MX MY MZ NA NC NE NF NG NI NL NO NP NR NU NZ OM PA PE PF PG PH PK PL PM PN PR PS PT PW PY ' +
+    'QA RE RO RS RU RW SA SB SC SD SE SG SH SI SJ SK SL SM SN SO SR SS ST SV SX SY SZ TC TD TF TG ' +
+    'TH TJ TK TL TM TN TO TR TT TV TW TZ UA UG UM US UY UZ VA VC VE VG VI VN VU WF WS XK YE YT ZA ' +
+    'ZM ZW').split(' ');
+const displayNames = new Map();
+/** The name of the country `code` in `locale`, or the code itself when Intl cannot name it. */
+export function countryName(code, locale) {
+    const key = locale ?? '';
+    if (!displayNames.has(key)) {
+        try {
+            displayNames.set(key, new Intl.DisplayNames(locale ? [locale] : undefined, { type: 'region' }));
+        }
+        catch {
+            displayNames.set(key, null);
+        }
+    }
+    const upper = code.toUpperCase();
+    try {
+        return displayNames.get(key)?.of(upper) ?? upper;
+    }
+    catch {
+        return upper;
+    }
+}

package/dist/components/Address/address.mcp.d.ts

@@ -0,0 +1 @@
+export declare const addressDescription = "\n# Address\n\n`entasis/address` holds the address model, the line order of each country, an `<Address>` display component, and the Google Places search `AddressInput` uses by default (with the server route that serves it).\n\n## Display\n\n```svelte\n<script lang=\"ts\">\n  import { Address, type AddressValue } from './index.ts';\n\n  const office: AddressValue = {\n    line1: '12 Rue de Rivoli',\n    postalCode: '75004',\n    city: 'Paris',\n    countryCode: 'FR'\n  };\n</script>\n\n<Address address={office} />\n<Address address={office} layout=\"inline\" fields={['line1', 'city']} />\n```\n\nProps:\n\n- **address**: `AddressValue | null` \u2014 the address to display.\n- **fields**: `AddressField[]` \u2014 parts to show (`line1`, `line2`, `postalCode`, `city`, `region`, `country`). Defaults to every part. The order on screen follows the country, not this list.\n- **layout**: `'block' | 'inline'` (default `'block'`) \u2014 one line per row, or every line joined by \", \".\n- **size**: `'small' | 'normal' | 'large'` \u2014 text size.\n- **empty**: `string | Snippet` \u2014 shown when nothing is left to display.\n- **ref**, **class**, **theme** (parts `root`, `line`, `empty`), and native attributes of the root `<address>`.\n\n## The address value\n\n```ts\ntype AddressValue = {\n  line1?: string | null;       // \"12 Rue de Rivoli\", \"Friedrichstra\u00DFe 43\"\n  line2?: string | null;       // apartment, suite, building\n  postalCode?: string | null;\n  city?: string | null;\n  region?: string | null;      // state, province (\"CA\" in the US, Canada and Australia)\n  country?: string | null;     // country name\n  countryCode?: string | null; // ISO 3166-1 alpha-2, decides the line order\n  streetNumber?: string | null;\n  street?: string | null;\n  formatted?: string | null;   // the provider's one-line address\n  placeId?: string | null;\n  location?: { lat: number; lng: number } | null;\n};\n```\n\n`streetNumber`, `street`, `formatted`, `placeId` and `location` come from a provider and are cleared by a manual edit that no longer matches them.\n\n## Formatting\n\n- `formatAddress(value, { fields?, locale? })` returns the lines in the country's order: street lines, then \"75004 Paris\" in most of Europe and Latin America, \"Mountain View, CA 94043\" in the US, Canada and Australia, the city and the postcode on their own lines in the UK and Ireland, then the country (named in `locale` when only `countryCode` is set).\n- `formatAddressLine(value, options)` joins them with \", \".\n- `composeStreetLine(number, street, countryCode)` writes the number before the street, or after it in Germany, the Netherlands, Italy, Spain, Scandinavia, Latin America and the rest of continental Europe.\n- `isAddressEmpty(value)`, `countryName(code, locale)`, `addressCountryName(value, locale)`, `COUNTRY_CODES`, `ADDRESS_FIELDS`.\n\n## Providers\n\nAn `AddressProvider` is two functions: `search(query, request)` returns `{ id, label, description? }` suggestions, and `resolve(id, request)` returns the full address. `request` carries `signal`, a `session` id shared by the searches and the resolve of one chosen address, `language` and `countries`.\n\n### Google Places, built in\n\nAddressInput searches Google Places by itself, through the app's `/api/places` route. That route is the whole setup:\n\n```ts nocheck\n// src/routes/api/places/[...path]/+server.ts\nimport { createGooglePlacesProxy } from 'entasis/address';\nimport { GOOGLE_PLACE_API_KEY } from '$app/env/private';\n\nexport const { GET, POST } = createGooglePlacesProxy({ apiKey: GOOGLE_PLACE_API_KEY });\n```\n\n- `createGooglePlacesProxy({ apiKey, fetch? })` returns `GET` and `POST` request handlers (`({ request }) => Response`, so SvelteKit and any Fetch-API server take them). They forward exactly two calls to Places API (New) with the server's key: `POST \u2026/places:autocomplete` and `GET \u2026/places/{id}` (field mask `id,formattedAddress,addressComponents,location`). Anything else, or a missing key, answers 404: the route is not an open proxy, and the key never reaches the page. Restrict the key to Places API (New) in the Google Cloud console.\n- Without the route (it answers 404), the search turns itself off for the page and the parts are typed by hand; the dev server warns once.\n- `DEFAULT_ADDRESS_ENDPOINT` is `'/api/places'`.\n\n### Another provider, or none\n\n- `setAddressProvider(provider)` in a layout sets the search for every AddressInput below, such as `createGooglePlacesProvider({ apiKey: PUBLIC_KEY })` to call Google from the browser with a key restricted to your sites, or a provider for another service. `setAddressProvider(null)` turns the search off.\n- An AddressInput's own `provider` prop wins over both; `provider={null}` turns its search off.\n\n### createGooglePlacesProvider\n\n```ts\nimport { createGooglePlacesProvider } from 'entasis/address';\n\nconst fromBrowser = createGooglePlacesProvider({ apiKey: PUBLIC_GOOGLE_PLACES_KEY });\nconst throughAnotherRoute = createGooglePlacesProvider({ endpoint: '/geo/places' });\n```\n\n- Uses Places API (New) over REST: `POST {endpoint}/places:autocomplete` and `GET {endpoint}/places/{id}`. No Google SDK is loaded.\n- Options: `apiKey`, `endpoint` (default `https://places.googleapis.com/v1`), `language`, `region`, `types` (default `street_address`, `premise`, `subpremise`, `route`, so shops and landmarks stay out; `[]` for every place), `fetch`.\n- The session token groups the autocomplete calls and the details call, so Google bills one session per chosen address.\n- `parseGooglePlace(place)` turns a Place's `addressComponents` into an `AddressValue`: the street line in the country's order, `locality` (or `postal_town`, then the nearest sublocality or administrative level) as the city, the first administrative level as the region, and `location` as `{ lat, lng }`.\n- A failed request rejects with a `GooglePlacesError` carrying Google's message and the HTTP `status`; AddressInput shows the search as failed and keeps the parts editable.\n";

package/dist/components/Address/address.mcp.js

@@ -0,0 +1,100 @@
+export const addressDescription = `
+# Address
+
+\`entasis/address\` holds the address model, the line order of each country, an \`<Address>\` display component, and the Google Places search \`AddressInput\` uses by default (with the server route that serves it).
+
+## Display
+
+\`\`\`svelte
+<script lang="ts">
+  import { Address, type AddressValue } from './index.ts';
+
+  const office: AddressValue = {
+    line1: '12 Rue de Rivoli',
+    postalCode: '75004',
+    city: 'Paris',
+    countryCode: 'FR'
+  };
+</script>
+
+<Address address={office} />
+<Address address={office} layout="inline" fields={['line1', 'city']} />
+\`\`\`
+
+Props:
+
+- **address**: \`AddressValue | null\` — the address to display.
+- **fields**: \`AddressField[]\` — parts to show (\`line1\`, \`line2\`, \`postalCode\`, \`city\`, \`region\`, \`country\`). Defaults to every part. The order on screen follows the country, not this list.
+- **layout**: \`'block' | 'inline'\` (default \`'block'\`) — one line per row, or every line joined by ", ".
+- **size**: \`'small' | 'normal' | 'large'\` — text size.
+- **empty**: \`string | Snippet\` — shown when nothing is left to display.
+- **ref**, **class**, **theme** (parts \`root\`, \`line\`, \`empty\`), and native attributes of the root \`<address>\`.
+
+## The address value
+
+\`\`\`ts
+type AddressValue = {
+  line1?: string | null;       // "12 Rue de Rivoli", "Friedrichstraße 43"
+  line2?: string | null;       // apartment, suite, building
+  postalCode?: string | null;
+  city?: string | null;
+  region?: string | null;      // state, province ("CA" in the US, Canada and Australia)
+  country?: string | null;     // country name
+  countryCode?: string | null; // ISO 3166-1 alpha-2, decides the line order
+  streetNumber?: string | null;
+  street?: string | null;
+  formatted?: string | null;   // the provider's one-line address
+  placeId?: string | null;
+  location?: { lat: number; lng: number } | null;
+};
+\`\`\`
+
+\`streetNumber\`, \`street\`, \`formatted\`, \`placeId\` and \`location\` come from a provider and are cleared by a manual edit that no longer matches them.
+
+## Formatting
+
+- \`formatAddress(value, { fields?, locale? })\` returns the lines in the country's order: street lines, then "75004 Paris" in most of Europe and Latin America, "Mountain View, CA 94043" in the US, Canada and Australia, the city and the postcode on their own lines in the UK and Ireland, then the country (named in \`locale\` when only \`countryCode\` is set).
+- \`formatAddressLine(value, options)\` joins them with ", ".
+- \`composeStreetLine(number, street, countryCode)\` writes the number before the street, or after it in Germany, the Netherlands, Italy, Spain, Scandinavia, Latin America and the rest of continental Europe.
+- \`isAddressEmpty(value)\`, \`countryName(code, locale)\`, \`addressCountryName(value, locale)\`, \`COUNTRY_CODES\`, \`ADDRESS_FIELDS\`.
+
+## Providers
+
+An \`AddressProvider\` is two functions: \`search(query, request)\` returns \`{ id, label, description? }\` suggestions, and \`resolve(id, request)\` returns the full address. \`request\` carries \`signal\`, a \`session\` id shared by the searches and the resolve of one chosen address, \`language\` and \`countries\`.
+
+### Google Places, built in
+
+AddressInput searches Google Places by itself, through the app's \`/api/places\` route. That route is the whole setup:
+
+\`\`\`ts nocheck
+// src/routes/api/places/[...path]/+server.ts
+import { createGooglePlacesProxy } from './index.ts';
+import { GOOGLE_PLACE_API_KEY } from '$app/env/private';
+
+export const { GET, POST } = createGooglePlacesProxy({ apiKey: GOOGLE_PLACE_API_KEY });
+\`\`\`
+
+- \`createGooglePlacesProxy({ apiKey, fetch? })\` returns \`GET\` and \`POST\` request handlers (\`({ request }) => Response\`, so SvelteKit and any Fetch-API server take them). They forward exactly two calls to Places API (New) with the server's key: \`POST …/places:autocomplete\` and \`GET …/places/{id}\` (field mask \`id,formattedAddress,addressComponents,location\`). Anything else, or a missing key, answers 404: the route is not an open proxy, and the key never reaches the page. Restrict the key to Places API (New) in the Google Cloud console.
+- Without the route (it answers 404), the search turns itself off for the page and the parts are typed by hand; the dev server warns once.
+- \`DEFAULT_ADDRESS_ENDPOINT\` is \`'/api/places'\`.
+
+### Another provider, or none
+
+- \`setAddressProvider(provider)\` in a layout sets the search for every AddressInput below, such as \`createGooglePlacesProvider({ apiKey: PUBLIC_KEY })\` to call Google from the browser with a key restricted to your sites, or a provider for another service. \`setAddressProvider(null)\` turns the search off.
+- An AddressInput's own \`provider\` prop wins over both; \`provider={null}\` turns its search off.
+
+### createGooglePlacesProvider
+
+\`\`\`ts
+import { createGooglePlacesProvider } from './index.ts';
+
+const fromBrowser = createGooglePlacesProvider({ apiKey: PUBLIC_GOOGLE_PLACES_KEY });
+const throughAnotherRoute = createGooglePlacesProvider({ endpoint: '/geo/places' });
+\`\`\`
+
+- Uses Places API (New) over REST: \`POST {endpoint}/places:autocomplete\` and \`GET {endpoint}/places/{id}\`. No Google SDK is loaded.
+- Options: \`apiKey\`, \`endpoint\` (default \`https://places.googleapis.com/v1\`), \`language\`, \`region\`, \`types\` (default \`street_address\`, \`premise\`, \`subpremise\`, \`route\`, so shops and landmarks stay out; \`[]\` for every place), \`fetch\`.
+- The session token groups the autocomplete calls and the details call, so Google bills one session per chosen address.
+- \`parseGooglePlace(place)\` turns a Place's \`addressComponents\` into an \`AddressValue\`: the street line in the country's order, \`locality\` (or \`postal_town\`, then the nearest sublocality or administrative level) as the city, the first administrative level as the region, and \`location\` as \`{ lat, lng }\`.
+- A failed request rejects with a \`GooglePlacesError\` carrying Google's message and the HTTP \`status\`; AddressInput shows the search as failed and keeps the parts editable.
+`;

package/dist/components/Address/address.props.d.ts

@@ -0,0 +1,26 @@
+import type { Slot } from '../Slot/slot.js';
+import type { WithAttachments } from '../../types/props.js';
+import type { Sizes } from '../../types/theme.js';
+import type { HTMLAttributes } from 'svelte/elements';
+import type { Address as AddressValue, AddressField } from './address.js';
+import type { AddressThemeProps } from './address.theme.js';
+/** `block` writes one line per row; `inline` joins the lines with ", " on one line. */
+export type AddressLayout = 'block' | 'inline';
+export type AddressProps = WithAttachments<Omit<HTMLAttributes<HTMLElement>, 'class' | 'children'> & {
+    /** The address to display. */
+    address: AddressValue | null | undefined;
+    /** Parts to display. Defaults to every part. Their order follows the country, not this list. */
+    fields?: readonly AddressField[];
+    /** One line per row, or every line on one. */
+    layout?: AddressLayout;
+    /** Text size. */
+    size?: Sizes;
+    /** Shown when the address has nothing to display. Defaults to nothing. */
+    empty?: Slot;
+    /** Bindable reference to the root `<address>`. */
+    ref?: HTMLElement | null;
+    /** Additional classes for the root `<address>`. */
+    class?: string;
+    /** Per-instance theme overrides. */
+    theme?: AddressThemeProps;
+}>;

package/dist/components/Address/address.props.js

@@ -0,0 +1 @@
+export {};

package/dist/components/Address/address.provider.d.ts

@@ -0,0 +1,19 @@
+import type { AddressProvider } from './address.js';
+/** The route the built-in provider searches through. */
+export declare const DEFAULT_ADDRESS_ENDPOINT = "/api/places";
+/**
+ * Sets the address search every AddressInput below uses, unless it is given its own `provider`.
+ * Call it in a layout, such as with `createGooglePlacesProvider({ apiKey })` for a browser key or
+ * another endpoint. Pass `null` to turn the search off.
+ */
+export declare function setAddressProvider(provider: AddressProvider | null): void;
+/** The provider set with `setAddressProvider` above this component, if any. */
+export declare function getAddressProvider(): {
+    provider: AddressProvider | null;
+} | undefined;
+/**
+ * Google Places through `/api/places`. When the app has no such route (it answers 404), the
+ * search turns itself off for the page: the fields stay, typed by hand, and the dev server says
+ * once how to add the route.
+ */
+export declare function builtInAddressProvider(): AddressProvider;

package/dist/components/Address/address.provider.js

@@ -0,0 +1,69 @@
+/**
+ * The address search a field uses when it is given none: Google Places through the app's own
+ * `/api/places` route (see `createGooglePlacesProxy`), or the provider set for the subtree.
+ */
+import { DEV } from 'esm-env';
+import { getContext, setContext } from 'svelte';
+import { createGooglePlacesProvider, GooglePlacesError } from './address.google.js';
+/** The route the built-in provider searches through. */
+export const DEFAULT_ADDRESS_ENDPOINT = '/api/places';
+const CONTEXT = Symbol('entasis.addressProvider');
+/**
+ * Sets the address search every AddressInput below uses, unless it is given its own `provider`.
+ * Call it in a layout, such as with `createGooglePlacesProvider({ apiKey })` for a browser key or
+ * another endpoint. Pass `null` to turn the search off.
+ */
+export function setAddressProvider(provider) {
+    setContext(CONTEXT, { provider });
+}
+/** The provider set with `setAddressProvider` above this component, if any. */
+export function getAddressProvider() {
+    return getContext(CONTEXT);
+}
+let builtIn;
+/**
+ * Google Places through `/api/places`. When the app has no such route (it answers 404), the
+ * search turns itself off for the page: the fields stay, typed by hand, and the dev server says
+ * once how to add the route.
+ */
+export function builtInAddressProvider() {
+    if (builtIn)
+        return builtIn;
+    const google = createGooglePlacesProvider({ endpoint: DEFAULT_ADDRESS_ENDPOINT });
+    let available = true;
+    const missing = (error) => {
+        if (!(error instanceof GooglePlacesError) || error.status !== 404)
+            return false;
+        available = false;
+        if (DEV)
+            console.warn(`entasis: AddressInput searches Google Places through ${DEFAULT_ADDRESS_ENDPOINT}, which this app does not serve. Add src/routes/api/places/[...path]/+server.ts with \`export const { GET, POST } = createGooglePlacesProxy({ apiKey })\` from 'entasis/address', or pass a \`provider\`.`);
+        return true;
+    };
+    builtIn = {
+        async search(query, request) {
+            if (!available)
+                return [];
+            try {
+                return await google.search(query, request);
+            }
+            catch (error) {
+                if (missing(error))
+                    return [];
+                throw error;
+            }
+        },
+        async resolve(id, request) {
+            if (!available)
+                return null;
+            try {
+                return await google.resolve(id, request);
+            }
+            catch (error) {
+                if (missing(error))
+                    return null;
+                throw error;
+            }
+        }
+    };
+    return builtIn;
+}

package/dist/components/Address/address.theme.d.ts

@@ -0,0 +1,63 @@
+import { type InferComponentTheme } from '../../utils/cva/index.js';
+export declare const addressTheme: {
+    root: (props?: (import("../../utils/cva/types.ts").CVAVariantSchema<{
+        size: {
+            small: string;
+            normal: string;
+            large: string;
+        };
+        layout: {
+            block: string;
+            inline: string;
+        };
+    }> & import("../../utils/cva/types.ts").CVAClassProp) | undefined) => string;
+    line: (props?: (import("../../utils/cva/types.ts").CVAVariantSchema<{
+        layout: {
+            block: string;
+            inline: string;
+        };
+    }> & import("../../utils/cva/types.ts").CVAClassProp) | undefined) => string;
+    empty: (props?: import("../../utils/cva/types.ts").CVAClassProp | undefined) => string;
+};
+export type AddressTheme = typeof addressTheme;
+export type AddressThemeProps = InferComponentTheme<AddressTheme>;
+export declare const setAddressTheme: (theme: InferComponentTheme<{
+    root: (props?: (import("../../utils/cva/types.ts").CVAVariantSchema<{
+        size: {
+            small: string;
+            normal: string;
+            large: string;
+        };
+        layout: {
+            block: string;
+            inline: string;
+        };
+    }> & import("../../utils/cva/types.ts").CVAClassProp) | undefined) => string;
+    line: (props?: (import("../../utils/cva/types.ts").CVAVariantSchema<{
+        layout: {
+            block: string;
+            inline: string;
+        };
+    }> & import("../../utils/cva/types.ts").CVAClassProp) | undefined) => string;
+    empty: (props?: import("../../utils/cva/types.ts").CVAClassProp | undefined) => string;
+}>) => void;
+export declare const useAddressTheme: import("../../utils/cva/theme.ts").UseComponentTheme<{
+    root: (props?: (import("../../utils/cva/types.ts").CVAVariantSchema<{
+        size: {
+            small: string;
+            normal: string;
+            large: string;
+        };
+        layout: {
+            block: string;
+            inline: string;
+        };
+    }> & import("../../utils/cva/types.ts").CVAClassProp) | undefined) => string;
+    line: (props?: (import("../../utils/cva/types.ts").CVAVariantSchema<{
+        layout: {
+            block: string;
+            inline: string;
+        };
+    }> & import("../../utils/cva/types.ts").CVAClassProp) | undefined) => string;
+    empty: (props?: import("../../utils/cva/types.ts").CVAClassProp | undefined) => string;
+}>;

package/dist/components/Address/address.theme.js

@@ -0,0 +1,42 @@
+import { cva, setComponentTheme, useComponentTheme } from '../../utils/cva/index.js';
+// An <address> resets the browser's italic: it reads as plain text in the surrounding type.
+const defaultRoot = cva({
+    base: 'min-w-0 text-neutral not-italic',
+    variants: {
+        size: {
+            small: 'text-xs',
+            normal: 'text-sm',
+            large: 'text-base'
+        },
+        layout: {
+            block: 'flex flex-col',
+            inline: 'inline'
+        }
+    },
+    defaultVariants: {
+        size: 'normal',
+        layout: 'block'
+    }
+});
+const defaultLine = cva({
+    base: 'min-w-0',
+    variants: {
+        layout: {
+            block: 'block',
+            inline: 'inline'
+        }
+    },
+    defaultVariants: {
+        layout: 'block'
+    }
+});
+const defaultEmpty = cva({
+    base: 'text-neutral/70'
+});
+export const addressTheme = {
+    root: defaultRoot,
+    line: defaultLine,
+    empty: defaultEmpty
+};
+export const setAddressTheme = setComponentTheme('address');
+export const useAddressTheme = useComponentTheme('address', addressTheme);

package/dist/components/Address/index.d.ts

@@ -0,0 +1,6 @@
+export { default as Address } from './Address.svelte';
+export type { AddressLayout, AddressProps } from './address.props.js';
+export { ADDRESS_FIELDS, COUNTRY_CODES, addressCountryName, composeStreetLine, countryName, formatAddress, formatAddressLine, isAddressEmpty, type Address as AddressValue, type AddressField, type AddressLocation, type AddressProvider, type AddressProviderRequest, type AddressSuggestion, type FormatAddressOptions } from './address.js';
+export { DEFAULT_ADDRESS_ENDPOINT, setAddressProvider } from './address.provider.js';
+export { createGooglePlacesProvider, createGooglePlacesProxy, GooglePlacesError, parseGooglePlace, type GooglePlace, type GooglePlaceAddressComponent, type GooglePlacesProviderOptions, type GooglePlacesProxyOptions } from './address.google.js';
+export { addressTheme, setAddressTheme, useAddressTheme, type AddressTheme, type AddressThemeProps } from './address.theme.js';

package/dist/components/Address/index.js

@@ -0,0 +1,5 @@
+export { default as Address } from './Address.svelte';
+export { ADDRESS_FIELDS, COUNTRY_CODES, addressCountryName, composeStreetLine, countryName, formatAddress, formatAddressLine, isAddressEmpty } from './address.js';
+export { DEFAULT_ADDRESS_ENDPOINT, setAddressProvider } from './address.provider.js';
+export { createGooglePlacesProvider, createGooglePlacesProxy, GooglePlacesError, parseGooglePlace } from './address.google.js';
+export { addressTheme, setAddressTheme, useAddressTheme } from './address.theme.js';