fimo 0.7.0-experimental.2 → 0.7.0-staging.1

package/dist/runtime/content/client/createSingletonClient.js

@@ -1,108 +0,0 @@
-import { useMutation, useQuery, useQueryClient, useSuspenseQuery } from '@tanstack/react-query';
-import { apiBase, buildReadPath, fimoHeaders, interpretSchema, readSingletonLocale, referenceTargetUids, resolveClientHandle, splitWritePayload, validateReferences, withMutationLocale, wrapEntry, } from './internal.js';
-import { useQueryLocale } from './useQueryLocale.js';
-export function createSingletonClient(config) {
-    const references = config.references ?? {};
-    const info = interpretSchema(config.schema);
-    if (!info.isSingleton) {
-        throw new Error(`Schema "${info.uid}" is a collection — use createContentClient instead.`);
-    }
-    validateReferences(info, references);
-    const meta = { uid: info.uid, pascal: info.pascal, localized: info.localized };
-    const self = { wrapWithSource, meta };
-    const resolve = (uid) => uid === info.uid ? self : resolveClientHandle(references[uid]);
-    // Which reference fields point at a localized schema decides whether a
-    // non-localized singleton read must still send a locale. Target metas live
-    // on other modules in a possibly-cyclic graph, so this is derived lazily on
-    // first request, never at module init.
-    let localizedReferenceFields = null;
-    function getLocalizedReferenceFields() {
-        if (localizedReferenceFields) {
-            return localizedReferenceFields;
-        }
-        const fields = new Set();
-        for (const [key, field] of info.fields) {
-            if (field.type !== 'reference') {
-                continue;
-            }
-            const localizedTarget = referenceTargetUids(field).some((uid) => resolve(uid)?.meta?.localized !== false);
-            if (localizedTarget) {
-                fields.add(key);
-            }
-        }
-        localizedReferenceFields = fields;
-        return fields;
-    }
-    function wrapWithSource(entry) {
-        return wrapEntry(info, entry, { alwaysIncludeLocale: info.localized, resolve });
-    }
-    function readLocale(options, fallbackLocale) {
-        return fallbackLocale === undefined
-            ? readSingletonLocale(options, info.localized, getLocalizedReferenceFields())
-            : readSingletonLocale(options, info.localized, getLocalizedReferenceFields(), fallbackLocale);
-    }
-    function readPath(url, options) {
-        return buildReadPath(url, readLocale(options), options.populate, options.localeFallbacks);
-    }
-    async function get(options = {}) {
-        const res = await fetch(`${apiBase()}${readPath(`/documents/${info.uid}`, options)}`, {
-            headers: fimoHeaders(),
-        });
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-        const data = await res.json();
-        return wrapWithSource(data.data);
-    }
-    async function update(payload) {
-        const write = splitWritePayload(payload);
-        const url = buildReadPath(`/documents/${info.uid}`, readLocale({ locale: write.locale }), undefined);
-        const res = await fetch(`${apiBase()}${url}`, {
-            method: 'PUT',
-            headers: fimoHeaders({ 'Content-Type': 'application/json' }),
-            body: JSON.stringify({ data: write.data }),
-        });
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-        const data = await res.json();
-        return wrapWithSource(data.data);
-    }
-    const qk = {
-        root: [info.pascal],
-        document: (options = {}) => [info.pascal, 'document', options.locale, options.populate],
-    };
-    function useGet(options = {}) {
-        const locale = readLocale(options, useQueryLocale(options.locale));
-        const localizedOptions = { ...options, locale };
-        return useQuery({
-            queryKey: qk.document(localizedOptions),
-            queryFn: () => get(localizedOptions),
-        });
-    }
-    function useSuspenseGet(options = {}) {
-        const locale = readLocale(options, useQueryLocale(options.locale));
-        const localizedOptions = { ...options, locale };
-        return useSuspenseQuery({
-            queryKey: qk.document(localizedOptions),
-            queryFn: () => get(localizedOptions),
-        });
-    }
-    function useUpdate() {
-        const qc = useQueryClient();
-        const activeLocale = useQueryLocale();
-        return useMutation({
-            mutationFn: (payload) => update(withMutationLocale(payload, activeLocale)),
-            onSuccess: () => qc.invalidateQueries({ queryKey: qk.root }),
-        });
-    }
-    return {
-        meta,
-        wrapWithSource,
-        get,
-        update,
-        useGet,
-        useSuspenseGet,
-        useUpdate,
-    };
-}

package/dist/runtime/content/client/internal.d.ts

@@ -1,44 +0,0 @@
-import type { ContentClientHandle, ContentModuleRef, ContentSchema, ContentSchemaField } from './types.js';
-export interface InterpretedSchema {
-    uid: string;
-    pascal: string;
-    localized: boolean;
-    isSingleton: boolean;
-    fields: ReadonlyArray<readonly [string, ContentSchemaField]>;
-}
-export declare function interpretSchema(schema: ContentSchema): InterpretedSchema;
-export declare function referenceTargetUids(field: ContentSchemaField): readonly string[];
-export declare function validateReferences(info: InterpretedSchema, references: Readonly<Record<string, ContentModuleRef>>): void;
-export declare function apiBase(): string;
-export declare function defaultLocale(): string;
-export declare function fimoHeaders(extra?: Record<string, string>): Record<string, string>;
-interface LocaleReadOptions {
-    locale?: string;
-    populate?: string | readonly string[];
-}
-export declare function readCollectionLocale(options: LocaleReadOptions, fallbackLocale?: string): string;
-export declare function readSingletonLocale(options: LocaleReadOptions, ownerUsesLocale: boolean, localizedReferenceFields: ReadonlySet<string>, fallbackLocale?: string): string | undefined;
-export declare function buildReadPath(url: string, locale: string | undefined, populate: string | readonly string[] | undefined, localeFallbacks?: boolean): string;
-export declare function splitWritePayload(payload: Record<string, unknown>): {
-    data: Record<string, unknown>;
-    locale?: string;
-    documentId?: string;
-};
-export declare function withMutationLocale<T extends object>(payload: T, activeLocale: string): T & {
-    locale: string;
-};
-type ReferenceResolver = (uid: string) => ContentClientHandle | undefined;
-/**
- * A reference is either a client or a module namespace whose default export
- * is the client. Only ever called at request time — unwrapping a namespace's
- * `default` mid-cycle would read an uninitialized binding. A namespace can
- * plausibly carry BOTH a re-exported wrapWithSource and a default client, so
- * prefer whichever shape carries meta — the locale rules depend on it.
- */
-export declare function resolveClientHandle(ref: ContentModuleRef | undefined): ContentClientHandle | undefined;
-export declare function wrapEntry(info: InterpretedSchema, entry: Record<string, any>, options: {
-    alwaysIncludeLocale: boolean;
-    resolve: ReferenceResolver;
-}): Record<string, unknown>;
-export {};
-//# sourceMappingURL=internal.d.ts.map

package/dist/runtime/content/client/internal.js

@@ -1,236 +0,0 @@
-import { pascalCase } from 'change-case';
-// @ts-ignore - virtual module provided by fimoConfigPlugin in fimo/vite
-import fimoConfig from 'virtual:fimo-config';
-import { FimoBoolean, FimoMedia, FimoRichText, FimoString } from '../../primitives/lib/primitives.js';
-export function interpretSchema(schema) {
-    if (!schema || typeof schema.uid !== 'string' || schema.uid.length === 0) {
-        throw new Error('Content schema is missing a "uid".');
-    }
-    return {
-        uid: schema.uid,
-        pascal: pascalCase(schema.uid),
-        localized: schema.i18n?.enabled !== false,
-        isSingleton: schema.isSingleton ?? false,
-        // Codegen tolerates malformed field values (null, arrays, primitives) by
-        // treating them as untyped passthrough fields — mirror that.
-        fields: Object.entries(schema.fields ?? {}).map(([key, value]) => [key, value && typeof value === 'object' && !Array.isArray(value) ? value : {}]),
-    };
-}
-// Codegen treats an empty or non-string-bearing `targets` array as absent and
-// falls back to the monomorphic `target` — mirror that normalization so the
-// polymorphic/fixed decision, validation, and the singleton locale rule agree.
-function polymorphicTargetUids(field) {
-    if (!Array.isArray(field.targets)) {
-        return undefined;
-    }
-    const targets = field.targets.filter((uid) => typeof uid === 'string');
-    return targets.length > 0 ? targets : undefined;
-}
-export function referenceTargetUids(field) {
-    return polymorphicTargetUids(field) ?? (field.target ? [field.target] : []);
-}
-export function validateReferences(info, references) {
-    for (const [key, field] of info.fields) {
-        if (field.type !== 'reference') {
-            continue;
-        }
-        for (const uid of referenceTargetUids(field)) {
-            if (uid !== info.uid && !(uid in references)) {
-                throw new Error(`Schema "${info.uid}" field "${key}" references "${uid}", but "${uid}" is missing from the client's references map.`);
-            }
-        }
-    }
-}
-export function apiBase() {
-    // @ts-ignore - import.meta.env is a Vite feature, replaced at build time for both client and SSR
-    return import.meta.env.VITE_API_URL;
-}
-export function defaultLocale() {
-    return fimoConfig.i18n?.defaultLocale ?? 'en';
-}
-export function fimoHeaders(extra) {
-    const h = { ...extra };
-    // @ts-ignore - import.meta.env is a Vite feature
-    const branch = import.meta.env.VITE_FIMO_BRANCH;
-    if (branch) {
-        h['X-Fimo-Branch'] = branch;
-    }
-    return h;
-}
-function populateFields(populate) {
-    if (populate == null) {
-        return [];
-    }
-    return typeof populate === 'string' ? [populate] : [...populate];
-}
-export function readCollectionLocale(options, fallbackLocale = defaultLocale()) {
-    return options.locale ?? fallbackLocale;
-}
-export function readSingletonLocale(options, ownerUsesLocale, localizedReferenceFields, fallbackLocale = defaultLocale()) {
-    const populatesLocalizedTarget = populateFields(options.populate).some((field) => localizedReferenceFields.has(field));
-    return ownerUsesLocale || populatesLocalizedTarget ? (options.locale ?? fallbackLocale) : undefined;
-}
-export function buildReadPath(url, locale, populate, localeFallbacks) {
-    const u = new URL(url, 'http://fimo.local');
-    if (locale) {
-        u.searchParams.set('locale', locale);
-    }
-    if (populate != null) {
-        u.searchParams.set('populate', typeof populate === 'string' ? populate : populate.join(','));
-    }
-    if (localeFallbacks) {
-        u.searchParams.set('localeFallbacks', 'true');
-    }
-    return `${u.pathname}${u.search}`;
-}
-export function splitWritePayload(payload) {
-    const { id, entryId, documentId, locale, createdAt, updatedAt, ...data } = payload;
-    delete data.__fimo;
-    void id;
-    void entryId;
-    void createdAt;
-    void updatedAt;
-    return {
-        data,
-        ...(typeof locale === 'string' && locale.length > 0 ? { locale } : {}),
-        ...(typeof documentId === 'string' && documentId.length > 0 ? { documentId } : {}),
-    };
-}
-export function withMutationLocale(payload, activeLocale) {
-    const locale = payload.locale;
-    return { ...payload, locale: locale ?? activeLocale };
-}
-function isPopulatedEntry(value) {
-    if (value == null || typeof value !== 'object') {
-        return false;
-    }
-    const entry = value;
-    const fimo = entry.__fimo;
-    return (typeof entry.id === 'string' &&
-        fimo != null &&
-        typeof fimo === 'object' &&
-        typeof fimo.contentType === 'string');
-}
-function asClientHandle(candidate) {
-    if (candidate == null || typeof candidate !== 'object') {
-        return undefined;
-    }
-    const handle = candidate;
-    return typeof handle.wrapWithSource === 'function' ? handle : undefined;
-}
-/**
- * A reference is either a client or a module namespace whose default export
- * is the client. Only ever called at request time — unwrapping a namespace's
- * `default` mid-cycle would read an uninitialized binding. A namespace can
- * plausibly carry BOTH a re-exported wrapWithSource and a default client, so
- * prefer whichever shape carries meta — the locale rules depend on it.
- */
-export function resolveClientHandle(ref) {
-    if (ref == null) {
-        return undefined;
-    }
-    const direct = asClientHandle(ref);
-    const viaDefault = asClientHandle(ref.default);
-    if (viaDefault?.meta) {
-        return viaDefault;
-    }
-    if (direct?.meta) {
-        return direct;
-    }
-    return direct ?? viaDefault;
-}
-function unresolvableReference(uid) {
-    // The template's equivalent was a compile-time import error; degrading to
-    // silently unwrapped values would kill inline editing invisibly instead.
-    return new Error(`Cannot wrap populated reference to "${uid}": its module did not resolve to a content client.`);
-}
-/**
- * Populated polymorphic entries carry their type marker; the wrapper picks
- * the right per-type wrapping and stamps a top-level $type so the generated
- * union narrows in a switch. Raw (unpopulated) values and types outside the
- * field's declared targets pass through untouched.
- */
-function wrapPolymorphic(value, targetUids, resolve) {
-    if (!isPopulatedEntry(value)) {
-        return value;
-    }
-    const contentType = typeof value.__fimo.contentType === 'string' ? value.__fimo.contentType : null;
-    if (!contentType || !targetUids.includes(contentType)) {
-        return value;
-    }
-    const target = resolve(contentType);
-    if (!target) {
-        throw unresolvableReference(contentType);
-    }
-    const wrapped = target.wrapWithSource(value);
-    wrapped.$type = contentType;
-    return wrapped;
-}
-function wrapReference(value, uid, resolve) {
-    if (!isPopulatedEntry(value)) {
-        return value;
-    }
-    const target = resolve(uid);
-    if (!target) {
-        throw unresolvableReference(uid);
-    }
-    return target.wrapWithSource(value);
-}
-function wrapField(field, value, source, resolve) {
-    switch (field.type) {
-        case 'string':
-            return value != null ? new FimoString(value, source) : value;
-        case 'richtext':
-            return value != null ? new FimoRichText(value, source) : value;
-        case 'boolean':
-            return value != null ? new FimoBoolean(value, source) : value;
-        case 'media':
-            if (field.multiple) {
-                return (value?.map((m, i) => new FimoMedia(m, `${source}[${i}]`)) ?? value);
-            }
-            return value != null ? new FimoMedia(value, source) : value;
-        case 'reference': {
-            const polymorphic = polymorphicTargetUids(field);
-            if (polymorphic) {
-                if (field.many) {
-                    return Array.isArray(value) ? value.map((item) => wrapPolymorphic(item, polymorphic, resolve)) : value;
-                }
-                return wrapPolymorphic(value, polymorphic, resolve);
-            }
-            const uid = field.target;
-            if (!uid) {
-                return value;
-            }
-            if (field.many) {
-                return Array.isArray(value) ? value.map((item) => wrapReference(item, uid, resolve)) : value;
-            }
-            return wrapReference(value, uid, resolve);
-        }
-        default:
-            return value;
-    }
-}
-export function wrapEntry(info, entry, options) {
-    const id = entry.id;
-    const entryId = entry.entryId;
-    const documentId = entry.documentId ?? id;
-    const locale = entry.locale ?? defaultLocale();
-    const sourcePrefix = `${info.pascal}.id:${id}:${encodeURIComponent(locale)}`;
-    const entryFimo = entry.__fimo && typeof entry.__fimo === 'object' ? entry.__fimo : {};
-    const wrapped = {
-        id,
-        entryId,
-        documentId,
-        slug: entry.slug != null ? new FimoString(entry.slug, `${sourcePrefix}.slug`) : entry.slug,
-        ...(options.alwaysIncludeLocale || entry.locale ? { locale } : {}),
-        createdAt: entry.createdAt,
-        updatedAt: entry.updatedAt,
-        __fimo: {
-            contentType: typeof entryFimo.contentType === 'string' ? entryFimo.contentType : info.uid,
-        },
-    };
-    for (const [key, field] of info.fields) {
-        wrapped[key] = wrapField(field, entry[key], `${sourcePrefix}.${key}`, options.resolve);
-    }
-    return wrapped;
-}

package/dist/runtime/content/client/types.d.ts

@@ -1,136 +0,0 @@
-import type { InfiniteData, UseInfiniteQueryResult, UseMutationResult, UseQueryResult, UseSuspenseQueryResult } from '@tanstack/react-query';
-import type { Fields, Populate, PopulatedResult, ProjectedWithPopulate, Query } from '../../primitives/lib/query.js';
-/**
- * Result shape of a read: the entity with populated references applied and
- * field projection narrowed — the runtime equivalent of the generated
- * `{Uid}Result` alias.
- */
-export type ContentResult<T extends {
-    id: string;
-}, TFields extends Fields<T> | undefined = undefined, TPopulate extends Populate<T> | undefined = undefined> = ProjectedWithPopulate<PopulatedResult<T, TPopulate> & {
-    id: string;
-}, TFields, TPopulate>;
-/**
- * The schema definition as written in `src/schemas/<uid>.json`. The factory
- * interprets it directly — the schema is the descriptor, so generated code
- * never transcribes field shapes into a second format that could drift.
- */
-export interface ContentSchemaField {
-    type?: string;
-    required?: boolean;
-    /** Media fields: multiple assets. */
-    multiple?: boolean;
-    /** Reference fields: to-many. */
-    many?: boolean;
-    /** Reference fields: target schema uid (may be this schema's own uid). */
-    target?: string;
-    /** Polymorphic reference fields: allowed target schema uids. */
-    targets?: readonly string[];
-}
-export interface ContentSchema {
-    uid: string;
-    name?: string;
-    isSingleton?: boolean;
-    i18n?: {
-        enabled?: boolean;
-    };
-    fields?: Readonly<Record<string, ContentSchemaField>>;
-}
-export interface ContentModuleMeta {
-    readonly uid: string;
-    readonly pascal: string;
-    readonly localized: boolean;
-}
-export interface ContentClientHandle {
-    wrapWithSource: (entry: Record<string, any>) => unknown;
-    meta: ContentModuleMeta;
-}
-/**
- * A cross-referenced generated module — either a client directly, or a module
- * namespace whose default export is the client. Generated modules for schemas
- * that reference each other form ESM cycles, so the factory only reads
- * properties off a ref lazily at request time, never while the client is
- * being constructed — a namespace import is safe to pass here even mid-cycle.
- */
-export type ContentModuleRef = ContentClientHandle | {
-    default: ContentClientHandle;
-};
-export interface ContentClientConfig {
-    schema: ContentSchema;
-    /**
-     * Every OTHER schema module this schema references, keyed by uid —
-     * `references: { Author, Video }` with namespace imports. Self-references
-     * resolve internally and never appear here.
-     */
-    references?: Readonly<Record<string, ContentModuleRef>>;
-}
-export interface ContentReadOptions<TPopulate> {
-    locale?: string;
-    populate?: TPopulate;
-    localeFallbacks?: boolean;
-}
-export interface CollectionPageInfo {
-    readonly limit: number;
-    readonly offset: number;
-    readonly total: number;
-    readonly hasMore: boolean;
-    readonly nextOffset: number | null;
-}
-export interface CollectionPage<TItem> {
-    readonly items: TItem[];
-    readonly pageInfo: CollectionPageInfo;
-}
-export type InfiniteListResult<TItem> = UseInfiniteQueryResult<InfiniteData<CollectionPage<TItem>>, Error> & {
-    readonly items: TItem[];
-    readonly total: number;
-    readonly hasMore: boolean;
-    readonly loadMore: () => ReturnType<UseInfiniteQueryResult<InfiniteData<CollectionPage<TItem>>, Error>['fetchNextPage']>;
-    readonly isLoadingMore: boolean;
-};
-export interface CollectionContentClient<T extends {
-    id: string;
-}, TInput> {
-    readonly meta: ContentModuleMeta;
-    wrapWithSource(entry: Record<string, any>): T;
-    getById<TPopulate extends Populate<T> | undefined = undefined>(id: string, options?: ContentReadOptions<TPopulate>): Promise<ContentResult<T, undefined, TPopulate>>;
-    getBySlug<TPopulate extends Populate<T> | undefined = undefined>(slug: string, options?: ContentReadOptions<TPopulate>): Promise<ContentResult<T, undefined, TPopulate> | null>;
-    getByField<TPopulate extends Populate<T> | undefined = undefined>(fieldName: string, value: string, options?: ContentReadOptions<TPopulate>): Promise<ContentResult<T, undefined, TPopulate> | null>;
-    list<TFields extends Fields<T> | undefined = undefined, TPopulate extends Populate<T> | undefined = undefined>(params?: Query<T, TFields, TPopulate>): Promise<CollectionPage<ContentResult<T, TFields, TPopulate>>>;
-    get<TFields extends Fields<T> | undefined = undefined, TPopulate extends Populate<T> | undefined = undefined>(params?: Query<T, TFields, TPopulate>): Promise<ContentResult<T, TFields, TPopulate>[]>;
-    create(payload: TInput): Promise<T>;
-    update(id: string, payload: Partial<TInput>): Promise<T>;
-    remove(id: string, options?: {
-        locale?: string;
-    }): Promise<void>;
-    useGetById<TPopulate extends Populate<T> | undefined = undefined>(id: string, options?: ContentReadOptions<TPopulate>): UseQueryResult<ContentResult<T, undefined, TPopulate>, Error>;
-    useGetBySlug<TPopulate extends Populate<T> | undefined = undefined>(slug: string, options?: ContentReadOptions<TPopulate>): UseQueryResult<ContentResult<T, undefined, TPopulate> | null, Error>;
-    useGetByField<TPopulate extends Populate<T> | undefined = undefined>(fieldName: string, value: string, options?: ContentReadOptions<TPopulate>): UseQueryResult<ContentResult<T, undefined, TPopulate> | null, Error>;
-    useGet<TFields extends Fields<T> | undefined = undefined, TPopulate extends Populate<T> | undefined = undefined>(params?: Query<T, TFields, TPopulate>): UseQueryResult<ContentResult<T, TFields, TPopulate>[], Error>;
-    useList<TFields extends Fields<T> | undefined = undefined, TPopulate extends Populate<T> | undefined = undefined>(params?: Query<T, TFields, TPopulate>): UseQueryResult<CollectionPage<ContentResult<T, TFields, TPopulate>>, Error>;
-    useInfiniteList<TFields extends Fields<T> | undefined = undefined, TPopulate extends Populate<T> | undefined = undefined>(params?: Omit<Query<T, TFields, TPopulate>, 'offset'>): InfiniteListResult<ContentResult<T, TFields, TPopulate>>;
-    useSuspenseGetById<TPopulate extends Populate<T> | undefined = undefined>(id: string, options?: ContentReadOptions<TPopulate>): UseSuspenseQueryResult<ContentResult<T, undefined, TPopulate>, Error>;
-    useSuspenseGetBySlug<TPopulate extends Populate<T> | undefined = undefined>(slug: string, options?: ContentReadOptions<TPopulate>): UseSuspenseQueryResult<ContentResult<T, undefined, TPopulate> | null, Error>;
-    useSuspenseGetByField<TPopulate extends Populate<T> | undefined = undefined>(fieldName: string, value: string, options?: ContentReadOptions<TPopulate>): UseSuspenseQueryResult<ContentResult<T, undefined, TPopulate> | null, Error>;
-    useSuspenseGet<TFields extends Fields<T> | undefined = undefined, TPopulate extends Populate<T> | undefined = undefined>(params?: Query<T, TFields, TPopulate>): UseSuspenseQueryResult<ContentResult<T, TFields, TPopulate>[], Error>;
-    useCreate(): UseMutationResult<T, Error, TInput>;
-    useUpdate(): UseMutationResult<T, Error, {
-        id: string;
-        locale?: string;
-    } & Partial<TInput>>;
-    useRemove(): UseMutationResult<void, Error, string | {
-        id: string;
-        locale?: string;
-    }>;
-}
-export interface SingletonContentClient<T extends {
-    id: string;
-}, TInput> {
-    readonly meta: ContentModuleMeta;
-    wrapWithSource(entry: Record<string, any>): T;
-    get<TPopulate extends Populate<T> | undefined = undefined>(options?: ContentReadOptions<TPopulate>): Promise<ContentResult<T, undefined, TPopulate>>;
-    update(payload: Partial<TInput>): Promise<T>;
-    useGet<TPopulate extends Populate<T> | undefined = undefined>(options?: ContentReadOptions<TPopulate>): UseQueryResult<ContentResult<T, undefined, TPopulate>, Error>;
-    useSuspenseGet<TPopulate extends Populate<T> | undefined = undefined>(options?: ContentReadOptions<TPopulate>): UseSuspenseQueryResult<ContentResult<T, undefined, TPopulate>, Error>;
-    useUpdate(): UseMutationResult<T, Error, Partial<TInput>>;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/runtime/content/client/useQueryLocale.d.ts

@@ -1,2 +0,0 @@
-export declare function useQueryLocale(locale?: string): string;
-//# sourceMappingURL=useQueryLocale.d.ts.map

package/dist/runtime/content/client/useQueryLocale.js

@@ -1,6 +0,0 @@
-import { useLocale } from '../../i18n/FimoLocaleContext.js';
-import { defaultLocale } from './internal.js';
-export function useQueryLocale(locale) {
-    const activeLocale = useLocale().locale;
-    return locale ?? activeLocale ?? defaultLocale();
-}