@vitnode/core 0.0.1-canary.0

package/dist/src/content/server/translation-editorial-service.d.ts

@@ -0,0 +1,58 @@
+import type { Context } from "hono";
+import type { ContentActor, ContentRevisionMeta, ContentTranslationRevisionOperation, ContentTranslationRevisionSnapshot } from "../revisions";
+import type { ContentTranslationSchemas } from "../schemas";
+import type { AnyContentTypeDefinition, ContentLocalizedFieldName, ContentLocalizedUpdateValues, ContentLocalizedValues, ContentTranslationRow } from "../types";
+import type { ContentDeliveryOutcome } from "./delivery-writes";
+import type { ContentRevisionPage } from "./revisions-model";
+import type { ContentDatabase } from "./service";
+import type { ContentTranslationModel } from "./translation-model";
+import { ContentTranslationVersionConflict } from "../errors";
+export interface ContentTranslationEditorialOutcome<TDefinition> {
+    changed: boolean;
+    changedFields: ContentLocalizedFieldName<TDefinition>[];
+    delivery?: ContentDeliveryOutcome;
+    languageId: number;
+    locale: string;
+    operation: ContentTranslationRevisionOperation;
+    previousSlug: null | string;
+    restoredFromRevisionId: null | number;
+    revisionId: null | number;
+    row: ContentTranslationRow<TDefinition>;
+    version: number;
+}
+export interface ContentTranslationEditorialOptions {
+    actor: ContentActor;
+    tx?: ContentDatabase;
+}
+export interface ContentTranslationEditorialWriteOptions extends ContentTranslationEditorialOptions {
+    expectedVersion: number;
+}
+export interface ContentTranslationEditorialTransitionOptions extends ContentTranslationEditorialOptions {
+    expectedVersion?: number;
+}
+export interface ContentTranslationEditorialService<TDefinition> {
+    create: (itemId: number, locale: string, values: ContentLocalizedValues<TDefinition>, options: ContentTranslationEditorialOptions) => Promise<ContentTranslationEditorialOutcome<TDefinition>>;
+    delete: (itemId: number, locale: string, options: ContentTranslationEditorialWriteOptions) => Promise<ContentTranslationEditorialOutcome<TDefinition> | null>;
+    findRevision: (itemId: number, locale: string, revisionId: number) => Promise<ContentRevisionDetailForLocale | null>;
+    listRevisions: (itemId: number, locale: string, args?: {
+        cursor?: number;
+        limit?: number;
+    }) => Promise<ContentRevisionPage>;
+    publish: (itemId: number, locale: string, options: ContentTranslationEditorialTransitionOptions) => Promise<ContentTranslationEditorialOutcome<TDefinition> | null>;
+    restore: (itemId: number, locale: string, revisionId: number, options: ContentTranslationEditorialWriteOptions) => Promise<ContentTranslationEditorialOutcome<TDefinition> | null>;
+    unpublish: (itemId: number, locale: string, options: ContentTranslationEditorialTransitionOptions) => Promise<ContentTranslationEditorialOutcome<TDefinition> | null>;
+    update: (itemId: number, locale: string, values: ContentLocalizedUpdateValues<TDefinition>, options: ContentTranslationEditorialWriteOptions) => Promise<ContentTranslationEditorialOutcome<TDefinition> | null>;
+}
+export interface ContentRevisionDetailForLocale extends ContentRevisionMeta {
+    locale: string;
+    snapshot: ContentTranslationRevisionSnapshot;
+}
+export declare const createContentTranslationEditorialService: <TDefinition extends AnyContentTypeDefinition>({ c, definition, pluginId, schemas, translations, }: {
+    c: Context;
+    definition: TDefinition;
+    pluginId: string;
+    schemas: ContentTranslationSchemas<TDefinition>;
+    translations: ContentTranslationModel<TDefinition>;
+}) => ContentTranslationEditorialService<TDefinition>;
+export { ContentTranslationVersionConflict };
+//# sourceMappingURL=translation-editorial-service.d.ts.map

package/dist/src/content/server/translation-editorial-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translation-editorial-service.d.ts","sourceRoot":"","sources":["../../../../src/content/server/translation-editorial-service.ts"],"names":[],"mappings":"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"}

package/dist/src/content/server/translation-editorial-service.js

@@ -0,0 +1 @@
+import{isContentTranslationPubliclyVisible}from"../cache.js";import{ContentEngineError,ContentRevisionNotRestorable,ContentTranslationVersionConflict}from"../errors.js";import{partitionContentFields}from"../localization.js";import{contentFieldPath,contentInnerFields,splitContentFieldPath}from"../paths.js";import{applyContentDeliveryWrite,contentSlugHistoryFor}from"./delivery-writes.js";import{diffChangedPaths}from"./query.js";import{contentTranslationRevisionSnapshot,projectTranslationRevisionSnapshot}from"./revision-snapshot.js";import{createContentRevisionsModel}from"./revisions-model.js";import{createSlugNormalizer}from"./slugs.js";import{CONTENT_TRANSLATION_INITIAL_VERSION}from"./translation-model.js";export const createContentTranslationEditorialService=({c,definition,pluginId,schemas,translations})=>{const contentTypeId=definition.id;if(!definition.localization.enabled){throw new ContentEngineError("The translation editorial service needs `localization: { enabled: true, defaultLocale }` on the content type.",{contentTypeId})}if(!definition.editorial.enabled){throw new ContentEngineError("The translation editorial service needs `editorial: { enabled: true }` on the content type - without it there is no revision history for a translation to write to.",{contentTypeId})}const{localizedFields}=partitionContentFields(definition.fields);const localizedPaths=Object.entries(localizedFields).flatMap(([name,fieldValue])=>fieldValue.kind==="group"?Object.keys(contentInnerFields(fieldValue)).map(leaf=>contentFieldPath(name,leaf)):[name]);const slugField=Object.keys(localizedFields).find(name=>localizedFields[name].kind==="slug")??null;const{withUpdateSlugs}=createSlugNormalizer(contentTypeId,localizedFields);const deliveryEnabled=definition.delivery.enabled&&definition.delivery.slugScope==="localized";const slugHistory=contentSlugHistoryFor({c,definition,pluginId});const applyDelivery=async(tx,{after,before,itemId,languageId,locale})=>{if(!deliveryEnabled)return undefined;const base=await translations.findBasePublication(itemId,{tx})??{publishedAt:null,status:undefined};const visible=row=>{if(row===null)return false;return isContentTranslationPubliclyVisible({base,translation:{publishedAt:row.publishedAt,status:row.status}})};return await applyContentDeliveryWrite({definition,slugHistory,transition:{isPublic:visible(after),itemId,languageId,locale,previousSlug:slugOf(before),slug:slugOf(after),wasPublic:visible(before)},tx})};const invertTranslation=(operation,row)=>({...row,status:operation==="publish"?"draft":"published"});const revisionsFor=languageId=>createContentRevisionsModel({c,definition,languageId,pluginId});const language=async(locale,{requireEnabled,tx})=>await translations.resolveLanguage(locale,{requireEnabled,tx});const transact=async(options,body)=>{if(options.tx)return await body(options.tx);return await c.get("db").transaction(async tx=>await body(tx))};const slugOf=row=>{if(!row||slugField===null)return null;const value=row.values[slugField];return typeof value==="string"?value:null};const snapshotSource=row=>({...row.values,createdAt:row.createdAt,itemId:row.itemId,languageId:row.languageId,publishedAt:row.publishedAt??null,status:row.status,updatedAt:row.updatedAt,version:row.version});const capture=async(tx,{actor,changedFields,languageId,locale,operation,restoredFromRevisionId,row,version})=>await revisionsFor(languageId).capture(tx,{actor,changedFields,itemId:row.itemId,operation,restoredFromRevisionId,snapshot:contentTranslationRevisionSnapshot(definition,{...snapshotSource(row),version},{languageId,locale}),version});const unchanged=(operation,row)=>({changed:false,changedFields:[],languageId:row.languageId,locale:row.locale,operation,previousSlug:slugOf(row),restoredFromRevisionId:null,revisionId:null,row,version:row.version});const transition=async(itemId,locale,options,operation)=>await transact(options,async tx=>{const result=await translations[operation](itemId,locale,{expectedVersion:options.expectedVersion,tx});if(!result)return null;if(!result.changed)return unchanged(operation,result.row);const revisionId=await capture(tx,{actor:options.actor,changedFields:[],languageId:result.row.languageId,locale:result.row.locale,operation,row:result.row,version:result.version});const delivery=await applyDelivery(tx,{after:result.row,before:invertTranslation(operation,result.row),itemId:result.row.itemId,languageId:result.row.languageId,locale:result.row.locale});return{changed:true,changedFields:[],...delivery===undefined?{}:{delivery},languageId:result.row.languageId,locale:result.row.locale,operation,previousSlug:slugOf(result.row),restoredFromRevisionId:null,revisionId,row:result.row,version:result.version}});return{create:async(itemId,locale,values,options)=>await transact(options,async tx=>{const target=await language(locale,{requireEnabled:true,tx});const previous=await revisionsFor(target.id).latest(itemId,tx);const row=await translations.create(itemId,target.locale,values,{[CONTENT_TRANSLATION_INITIAL_VERSION]:(previous?.version??0)+1,tx});const revisionId=await capture(tx,{actor:options.actor,changedFields:localizedPaths,languageId:row.languageId,locale:row.locale,operation:"create",row,version:row.version});const delivery=await applyDelivery(tx,{after:row,before:null,itemId:row.itemId,languageId:row.languageId,locale:row.locale});const base=await translations.findBasePublication(itemId,{tx});const published=base?.status==="published"?await transition(itemId,row.locale,{actor:options.actor,tx},"publish"):null;const live=published?.changed===true?published:null;const outcome=live?.delivery??delivery;return{changed:true,changedFields:localizedPaths,...outcome===undefined?{}:{delivery:outcome},languageId:row.languageId,locale:row.locale,operation:"create",previousSlug:null,restoredFromRevisionId:null,revisionId,row:live?.row??row,version:live?.version??row.version}}),delete:async(itemId,locale,options)=>await transact(options,async tx=>{const row=await translations.delete(itemId,locale,{expectedVersion:options.expectedVersion,tx});if(!row)return null;const version=row.version+1;const revisionId=await capture(tx,{actor:options.actor,changedFields:[],languageId:row.languageId,locale:row.locale,operation:"delete",row,version});const delivery=await applyDelivery(tx,{after:null,before:row,itemId:row.itemId,languageId:row.languageId,locale:row.locale});return{changed:true,changedFields:[],...delivery===undefined?{}:{delivery},languageId:row.languageId,locale:row.locale,operation:"delete",previousSlug:slugOf(row),restoredFromRevisionId:null,revisionId,row,version}}),findRevision:async(itemId,locale,revisionId)=>{const target=await language(locale,{requireEnabled:false});const revision=await revisionsFor(target.id).findById(itemId,revisionId);if(!revision)return null;return{...revision,locale:target.locale}},listRevisions:async(itemId,locale,args)=>{const target=await language(locale,{requireEnabled:false});return await revisionsFor(target.id).list(itemId,args)},publish:async(itemId,locale,options)=>await transition(itemId,locale,options,"publish"),restore:async(itemId,locale,revisionId,options)=>await transact(options,async tx=>{const target=await language(locale,{requireEnabled:true,tx});const revision=await revisionsFor(target.id).findById(itemId,revisionId,tx);if(!revision)return null;const current=await translations.findByLanguageId(itemId,target.id,{tx});if(!current)return null;const projected=projectTranslationRevisionSnapshot(definition,revision.snapshot);const parsed=schemas.update.safeParse(projected);if(!parsed.success){throw new ContentRevisionNotRestorable({contentTypeId,fields:[...new Set(parsed.error.issues.map(issue=>String(issue.path[0]??"")).filter(name=>name!==""))],revisionId})}const patch=withUpdateSlugs(parsed.data);const currentValues=current.values;const changedFields=diffChangedPaths(localizedFields,currentValues,patch);if(changedFields.length===0){return{...unchanged("restore",current),restoredFromRevisionId:null}}const result=await translations.update(itemId,target.locale,Object.fromEntries([...new Set(changedFields.map(path=>splitContentFieldPath(path)?.[0]??path))].map(key=>[key,patch[key]])),{expectedVersion:options.expectedVersion,tx});if(!result)return null;if(!result.changed){return{...unchanged("restore",result.row),restoredFromRevisionId:null}}const newRevisionId=await capture(tx,{actor:options.actor,changedFields:result.changedFields,languageId:result.row.languageId,locale:result.row.locale,operation:"restore",restoredFromRevisionId:revisionId,row:result.row,version:result.version});const delivery=await applyDelivery(tx,{after:result.row,before:current,itemId:result.row.itemId,languageId:result.row.languageId,locale:result.row.locale});return{changed:true,changedFields:result.changedFields,...delivery===undefined?{}:{delivery},languageId:result.row.languageId,locale:result.row.locale,operation:"restore",previousSlug:slugOf(current),restoredFromRevisionId:revisionId,revisionId:newRevisionId,row:result.row,version:result.version}}),unpublish:async(itemId,locale,options)=>await transition(itemId,locale,options,"unpublish"),update:async(itemId,locale,values,options)=>await transact(options,async tx=>{const before=await translations.findByLocale(itemId,locale,{tx});const result=await translations.update(itemId,locale,values,{expectedVersion:options.expectedVersion,tx});if(!result)return null;if(!result.changed)return unchanged("update",result.row);const revisionId=await capture(tx,{actor:options.actor,changedFields:result.changedFields,languageId:result.row.languageId,locale:result.row.locale,operation:"update",row:result.row,version:result.version});const delivery=await applyDelivery(tx,{after:result.row,before,itemId:result.row.itemId,languageId:result.row.languageId,locale:result.row.locale});return{changed:true,changedFields:result.changedFields,...delivery===undefined?{}:{delivery},languageId:result.row.languageId,locale:result.row.locale,operation:"update",previousSlug:slugOf(before),restoredFromRevisionId:null,revisionId,row:result.row,version:result.version}})}};export{ContentTranslationVersionConflict};

package/dist/src/content/server/translation-effects.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from "hono";
+import type { EventEmitResult } from "../../api/models/events";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentDeliveryEffectsResult } from "./delivery-effects";
+import type { AnyContentModel } from "./model";
+import type { ContentSearchSyncOutcome } from "./search-sync";
+import type { ContentTranslationEditorialOutcome } from "./translation-editorial-service";
+export interface ContentTranslationEffectsOptions {
+    model?: AnyContentModel;
+    pluginId: string;
+}
+export interface ContentTranslationEffectsResult {
+    delivery?: ContentDeliveryEffectsResult;
+    event: EventEmitResult | null;
+    search?: ContentSearchSyncOutcome[];
+}
+export declare const contentTranslationEffects: (c: Context, definition: AnyContentTypeDefinition, outcome: ContentTranslationEditorialOutcome<AnyContentTypeDefinition>, { model, pluginId }: ContentTranslationEffectsOptions) => Promise<ContentTranslationEffectsResult>;
+//# sourceMappingURL=translation-effects.d.ts.map

package/dist/src/content/server/translation-effects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translation-effects.d.ts","sourceRoot":"","sources":["../../../../src/content/server/translation-effects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,iCAAiC,CAAC;AAyD1F,MAAM,WAAW,gCAAgC;IAQ/C,KAAK,CAAC,EAAE,eAAe,CAAC;IAExB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,+BAA+B;IAK9C,QAAQ,CAAC,EAAE,4BAA4B,CAAC;IASxC,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;IAO9B,MAAM,CAAC,EAAE,wBAAwB,EAAE,CAAC;CACrC;AAuBD,eAAO,MAAM,yBAAyB,GACpC,GAAG,OAAO,EACV,YAAY,wBAAwB,EACpC,SAAS,kCAAkC,CAAC,wBAAwB,CAAC,EACrE,qBAAqB,gCAAgC,KACpD,OAAO,CAAC,+BAA+B,CAyDzC,CAAC"}

package/dist/src/content/server/translation-effects.js

@@ -0,0 +1 @@
+import{contentDeliveryEffects}from"./delivery-effects.js";import{reportContentEventFailures}from"./effects-log.js";import{emitContentEvent}from"./emit.js";import{contentSearchAdvancedValues,syncContentLocalizedSearch}from"./search-sync.js";const EVENT_ACTION={create:"translation_created",delete:"translation_deleted",publish:"translation_published",restore:"translation_restored",unpublish:"translation_unpublished",update:"translation_updated"};const payloadFor=outcome=>{const base={contentId:outcome.row.itemId,languageId:outcome.languageId,locale:outcome.locale,...outcome.revisionId===null?{}:{revisionId:outcome.revisionId},version:outcome.version};switch(outcome.operation){case"publish":return{...base,publishedAt:outcome.row.publishedAt??null};case"restore":return{...base,changedFields:outcome.changedFields,restoredFromRevisionId:outcome.restoredFromRevisionId};case"update":return{...base,changedFields:outcome.changedFields};default:return base}};export const contentTranslationEffects=async(c,definition,outcome,{model,pluginId})=>{if(!outcome.changed)return{event:null};const event=await emitContentEvent(c,definition,EVENT_ACTION[outcome.operation],payloadFor(outcome),{pluginId});await reportContentEventFailures(c,{action:EVENT_ACTION[outcome.operation],contentTypeId:definition.id,event,itemId:outcome.row.itemId,locale:outcome.locale});const delivery=definition.delivery.enabled?await contentDeliveryEffects(c,definition,outcome.delivery,{pluginId}):undefined;const withDelivery=delivery===undefined?{}:{delivery};if(!definition.search.enabled||!model)return{...withDelivery,event};const base=await model.service(c).findById(outcome.row.itemId);if(!base)return{...withDelivery,event};return{...withDelivery,event,search:await syncContentLocalizedSearch(c,model,{advanced:await contentSearchAdvancedValues(c,model,outcome.row.itemId),changed:outcome.changed,changedFields:outcome.changedFields,locale:outcome.locale,operation:outcome.operation,pluginId,row:base})}};

package/dist/src/content/server/translation-http-errors.d.ts

@@ -0,0 +1,9 @@
+import { HTTPException } from "hono/http-exception";
+import type { ContentTranslationConflict } from "../conflicts";
+export declare const contentTranslationConflict: (body: ContentTranslationConflict) => HTTPException;
+export declare const withTranslationHttpErrors: <TResult>(action: "create" | "delete" | "read" | "update", run: () => Promise<TResult>, { contentTypeId, itemId, locale, }: {
+    contentTypeId: string;
+    itemId?: number;
+    locale?: string;
+}) => Promise<TResult>;
+//# sourceMappingURL=translation-http-errors.d.ts.map

package/dist/src/content/server/translation-http-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translation-http-errors.d.ts","sourceRoot":"","sources":["../../../../src/content/server/translation-http-errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGpD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AA0B/D,eAAO,MAAM,0BAA0B,GACrC,MAAM,0BAA0B,KAC/B,aACoE,CAAC;AAuBxE,eAAO,MAAM,yBAAyB,GAAU,OAAO,EACrD,QAAQ,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,EAC/C,KAAK,MAAM,OAAO,CAAC,OAAO,CAAC,EAC3B,oCAIG;IACD,aAAa,EAAE,MAAM,CAAC;IAEtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,KACA,OAAO,CAAC,OAAO,CAmIjB,CAAC"}

package/dist/src/content/server/translation-http-errors.js

@@ -0,0 +1 @@
+import{HTTPException}from"hono/http-exception";import{ZodError}from"zod";import{CONTENT_DELIVERY_CODES,CONTENT_TRANSLATION_CONFLICT_CODES,CONTENT_UNPROCESSABLE_CODES}from"../const.js";import{ContentDefaultTranslationRequired,ContentDeliverySlugReserved,ContentInputError,ContentLanguageError,ContentRevisionNotRestorable,ContentTranslationExists,ContentTranslationItemMissing,ContentTranslationVersionConflict}from"../errors.js";import{ContentFileReferenceError}from"./files.js";import{contentDeliveryConflict,contentFileRejected,contentUnprocessable,rethrowAsHttpError}from"./http-errors.js";export const contentTranslationConflict=body=>new HTTPException(409,{res:Response.json(body,{status:409})});export const withTranslationHttpErrors=async(action,run,{contentTypeId,itemId,locale})=>{try{return await run()}catch(error){if(error instanceof HTTPException)throw error;if(error instanceof ContentRevisionNotRestorable){throw contentUnprocessable({code:CONTENT_UNPROCESSABLE_CODES.notRestorable,contentTypeId,fields:error.fields,revisionId:error.revisionId})}if(error instanceof ContentTranslationVersionConflict){throw contentTranslationConflict({code:CONTENT_TRANSLATION_CONFLICT_CODES.version,contentTypeId,currentVersion:error.currentVersion,expectedVersion:error.expectedVersion,itemId:error.itemId,locale:error.locale})}if(error instanceof ContentDefaultTranslationRequired){throw contentTranslationConflict({code:CONTENT_TRANSLATION_CONFLICT_CODES.defaultRequired,contentTypeId,itemId:error.itemId,locale:error.locale})}if(error instanceof ContentTranslationExists){throw contentTranslationConflict({code:CONTENT_TRANSLATION_CONFLICT_CODES.exists,contentTypeId,itemId:error.itemId,locale:error.locale})}if(error instanceof ContentLanguageError){if(error.reason==="missing"){throw new HTTPException(404,{message:error.message})}throw contentTranslationConflict({code:CONTENT_TRANSLATION_CONFLICT_CODES.languageDisabled,contentTypeId,locale:error.locale})}if(error instanceof ContentTranslationItemMissing){throw new HTTPException(404,{message:error.message})}if(error instanceof ContentDeliverySlugReserved){throw contentDeliveryConflict({code:CONTENT_DELIVERY_CODES.slugReserved,contentTypeId,locale:error.locale,slug:error.slug})}if(error instanceof ContentFileReferenceError){throw contentFileRejected({code:error.code,field:error.field,message:error.detail})}if(error instanceof ContentInputError){throw new HTTPException(400,{message:error.message})}if(error instanceof ZodError){throw new HTTPException(400,{message:"Invalid input data."})}try{return rethrowAsHttpError(error,{action:action==="read"?"update":action,contentTypeId,itemId})}catch(mapped){if(mapped instanceof HTTPException&&mapped.status===409){throw contentTranslationConflict({code:CONTENT_TRANSLATION_CONFLICT_CODES.unique,contentTypeId,itemId:itemId??null,locale:locale??""})}throw mapped}}};

package/dist/src/content/server/translation-model.d.ts

@@ -0,0 +1,61 @@
+import type { PgColumn, PgTable } from "drizzle-orm/pg-core";
+import type { Context } from "hono";
+import type { ContentTranslationSchemas } from "../schemas";
+import type { AnyContentTypeDefinition, ContentLocalizedFieldName, ContentLocalizedUpdateValues, ContentLocalizedValues, ContentTranslationMeta, ContentTranslationRow } from "../types";
+import type { ContentLanguage } from "./language-resolver";
+import type { ContentDatabase } from "./service";
+export interface ContentTranslationOptions {
+    tx?: ContentDatabase;
+}
+export declare const CONTENT_TRANSLATION_INITIAL_VERSION: unique symbol;
+export interface ContentTranslationCreateOptions extends ContentTranslationOptions {
+    [CONTENT_TRANSLATION_INITIAL_VERSION]?: number;
+}
+export interface ContentTranslationWriteOptions extends ContentTranslationOptions {
+    expectedVersion: number;
+}
+export interface ContentTranslationUpdateResult<TDefinition> {
+    changed: boolean;
+    changedFields: ContentLocalizedFieldName<TDefinition>[];
+    row: ContentTranslationRow<TDefinition>;
+    version: number;
+}
+export interface ContentTranslationTransitionOptions extends ContentTranslationOptions {
+    expectedVersion?: number;
+}
+export interface ContentTranslationTransitionResult<TDefinition> {
+    changed: boolean;
+    row: ContentTranslationRow<TDefinition>;
+    version: number;
+}
+export interface ContentTranslationModel<TDefinition> {
+    create: (itemId: number, locale: string, values: ContentLocalizedValues<TDefinition>, options?: ContentTranslationCreateOptions) => Promise<ContentTranslationRow<TDefinition>>;
+    delete: (itemId: number, locale: string, options: ContentTranslationWriteOptions) => Promise<ContentTranslationRow<TDefinition> | null>;
+    exists: (itemId: number, locale: string, options?: ContentTranslationOptions) => Promise<boolean>;
+    findBasePublication: (itemId: number, options?: ContentTranslationOptions) => Promise<null | {
+        publishedAt: Date | null;
+        status: string | undefined;
+    }>;
+    findByLanguageId: (itemId: number, languageId: number, options?: ContentTranslationOptions) => Promise<ContentTranslationRow<TDefinition> | null>;
+    findByLocale: (itemId: number, locale: string, options?: ContentTranslationOptions) => Promise<ContentTranslationRow<TDefinition> | null>;
+    findManyByLanguageId: (itemIds: readonly number[], languageId: number, options?: ContentTranslationOptions) => Promise<ContentTranslationRow<TDefinition>[]>;
+    findManyForItem: (itemId: number, options?: ContentTranslationOptions) => Promise<ContentTranslationMeta<TDefinition>[]>;
+    findManyRowsForItem: (itemId: number, options?: ContentTranslationOptions) => Promise<ContentTranslationRow<TDefinition>[]>;
+    publish: (itemId: number, locale: string, options?: ContentTranslationTransitionOptions) => Promise<ContentTranslationTransitionResult<TDefinition> | null>;
+    resolveDefaultLanguage: (options?: ContentTranslationOptions) => Promise<ContentLanguage>;
+    resolveLanguage: (locale: string, options?: {
+        requireEnabled?: boolean;
+        tx?: ContentDatabase;
+    }) => Promise<ContentLanguage>;
+    unpublish: (itemId: number, locale: string, options?: ContentTranslationTransitionOptions) => Promise<ContentTranslationTransitionResult<TDefinition> | null>;
+    update: (itemId: number, locale: string, values: ContentLocalizedUpdateValues<TDefinition>, options: ContentTranslationWriteOptions) => Promise<ContentTranslationUpdateResult<TDefinition> | null>;
+}
+export declare const createContentTranslationModel: <TDefinition extends AnyContentTypeDefinition>({ c, columns, definition, schemas, table, translationTable, }: {
+    c: Context;
+    columns: Record<string, PgColumn>;
+    definition: TDefinition;
+    schemas: ContentTranslationSchemas<TDefinition>;
+    table: PgTable;
+    translationTable: PgTable;
+}) => ContentTranslationModel<TDefinition>;
+//# sourceMappingURL=translation-model.d.ts.map

package/dist/src/content/server/translation-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translation-model.d.ts","sourceRoot":"","sources":["../../../../src/content/server/translation-model.ts"],"names":[],"mappings":"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"}

package/dist/src/content/server/translation-model.js

@@ -0,0 +1 @@
+import{and,asc,eq,inArray,ne,sql}from"drizzle-orm";import{CONTENT_TRANSLATION_PUBLICATION_FIELDS,CONTENT_TRANSLATION_SYSTEM_FIELDS}from"../const.js";import{ContentDefaultTranslationRequired,ContentEngineError,ContentTranslationExists,ContentTranslationItemMissing,ContentTranslationVersionConflict}from"../errors.js";import{partitionContentFields}from"../localization.js";import{contentColumnsToValues,contentStorageColumns,contentValuesToColumns}from"../paths.js";import{contentDatabase,findContentLanguage,listContentLanguages,resolveContentLanguage}from"./language-resolver.js";import{diffChangedFields}from"./query.js";import{createSlugNormalizer}from"./slugs.js";export const CONTENT_TRANSLATION_INITIAL_VERSION=Symbol("vitnode.content.translation.initialVersion");const translationSystemFields=CONTENT_TRANSLATION_SYSTEM_FIELDS;const toNullableDate=value=>{if(value instanceof Date)return value;if(typeof value!=="string")return null;const parsed=new Date(value);return Number.isNaN(parsed.getTime())?null:parsed};export const createContentTranslationModel=({c,columns,definition,schemas,table,translationTable})=>{const contentTypeId=definition.id;if(!definition.localization.enabled){throw new ContentEngineError("The translation service needs `localization: { enabled: true, defaultLocale }` on the content type.",{contentTypeId})}const{localizedFields}=partitionContentFields(definition.fields);const localizedColumns=contentStorageColumns(localizedFields);const localizedNames=Object.keys(localizedColumns);const{defaultLocale}=definition.localization;const pathByColumn=new Map(definition.advanced.leaves.filter(leaf=>leaf.localized).map(leaf=>[leaf.columnName,leaf.path]));const itemColumn=columns.itemId;const languageColumn=columns.languageId;const versionColumn=columns.version;const baseId=table.id;const publication=definition.publication.enabled;const metaNames=[...translationSystemFields,...publication?CONTENT_TRANSLATION_PUBLICATION_FIELDS:[]];const{withCreateSlugs,withUpdateSlugs}=createSlugNormalizer(contentTypeId,localizedColumns);const metaSelection=()=>Object.fromEntries(metaNames.map(name=>[name,columns[name]]));const fullSelection=()=>({...metaSelection(),...Object.fromEntries(localizedNames.map(name=>[name,columns[name]]))});const db=options=>contentDatabase(c,options?.tx);const language=async(locale,{requireEnabled,tx})=>await resolveContentLanguage(c,{contentTypeId,locale,requireEnabled,tx});const publicationOf=row=>publication?{publishedAt:toNullableDate(row.publishedAt),status:row.status}:{};const toMeta=(row,locale)=>({...publicationOf(row),createdAt:row.createdAt,itemId:row.itemId,languageId:row.languageId,locale,updatedAt:row.updatedAt,version:row.version});const toRow=(row,locale)=>{const values=contentColumnsToValues(localizedFields,row);return{...toMeta(row,locale),values:values}};const versionOf=row=>typeof row.version==="number"?row.version:1;const readOne=async(itemId,languageId,database)=>{const[row]=await database.select(fullSelection()).from(translationTable).where(and(eq(itemColumn,itemId),eq(languageColumn,languageId))).limit(1);return row??null};const statusColumn=()=>{if(!publication){throw new ContentEngineError("Translations can only be published on a content type with `publication: { enabled: true }` - without it there is no status column for a translation status to be subordinate to.",{contentTypeId})}return columns.status};const transition=async(itemId,locale,options,{guard,requireEnabled,values})=>{const target=await language(locale,{requireEnabled,tx:options.tx});const database=db(options);const conditions=[eq(itemColumn,itemId),eq(languageColumn,target.id),guard];if(options.expectedVersion!==undefined){conditions.push(eq(versionColumn,options.expectedVersion))}const[row]=await database.update(translationTable).set({...values,version:sql`${versionColumn} + 1`}).where(and(...conditions)).returning(fullSelection());if(row){return{changed:true,row:toRow(row,target.locale),version:versionOf(row)}}const current=await readOne(itemId,target.id,database);if(!current)return null;if(options.expectedVersion!==undefined&&versionOf(current)!==options.expectedVersion){throw new ContentTranslationVersionConflict({contentTypeId,currentVersion:versionOf(current),expectedVersion:options.expectedVersion,itemId,locale:target.locale})}return{changed:false,row:toRow(current,target.locale),version:versionOf(current)}};const assertItemExists=async(itemId,database)=>{const[row]=await database.select({id:baseId}).from(table).where(eq(baseId,itemId)).limit(1);if(!row){throw new ContentTranslationItemMissing({contentTypeId,itemId})}};return{create:async(itemId,locale,values,options)=>{const target=await language(locale,{requireEnabled:true,tx:options?.tx});const database=db(options);await assertItemExists(itemId,database);const parsed=schemas.create.parse(values);const initialVersion=options?.[CONTENT_TRANSLATION_INITIAL_VERSION];if(initialVersion!==undefined&&(!Number.isInteger(initialVersion)||initialVersion<1)){throw new ContentEngineError(`A translation of ${itemId} cannot start at version ${String(initialVersion)} - versions are integers from 1 upwards.`,{contentTypeId})}const[row]=await database.insert(translationTable).values({...withCreateSlugs(contentValuesToColumns(localizedFields,parsed)),itemId,languageId:target.id,...initialVersion===undefined?{}:{version:initialVersion}}).onConflictDoNothing({target:[itemColumn,languageColumn]}).returning(fullSelection());if(row)return toRow(row,target.locale);throw new ContentTranslationExists({contentTypeId,itemId,locale:target.locale})},delete:async(itemId,locale,options)=>{const target=await language(locale,{requireEnabled:false,tx:options.tx});if(target.locale.toLowerCase()===defaultLocale.toLowerCase()){throw new ContentDefaultTranslationRequired({contentTypeId,itemId,locale:target.locale})}const database=db(options);const[row]=await database.delete(translationTable).where(and(eq(itemColumn,itemId),eq(languageColumn,target.id),eq(versionColumn,options.expectedVersion))).returning(fullSelection());if(row)return toRow(row,target.locale);const current=await readOne(itemId,target.id,database);if(!current)return null;throw new ContentTranslationVersionConflict({contentTypeId,currentVersion:versionOf(current),expectedVersion:options.expectedVersion,itemId,locale:target.locale})},exists:async(itemId,locale,options)=>{const target=await findContentLanguage(c,locale,options?.tx);if(!target)return false;const[row]=await db(options).select({itemId:itemColumn}).from(translationTable).where(and(eq(itemColumn,itemId),eq(languageColumn,target.id))).limit(1);return row!==undefined},findBasePublication:async(itemId,options)=>{const baseColumns=table;const[row]=await db(options).select(publication?{publishedAt:baseColumns.publishedAt,status:baseColumns.status}:{publishedAt:baseId,status:baseId}).from(table).where(eq(baseId,itemId)).limit(1);if(!row)return null;if(!publication)return{publishedAt:null,status:undefined};return{publishedAt:toNullableDate(row.publishedAt),status:typeof row.status==="string"?row.status:undefined}},findByLanguageId:async(itemId,languageId,options)=>{const row=await readOne(itemId,languageId,db(options));if(!row)return null;const languages=await listContentLanguagesById(c,options?.tx);return toRow(row,languages.get(languageId)?.locale??"")},findByLocale:async(itemId,locale,options)=>{const target=await findContentLanguage(c,locale,options?.tx);if(!target)return null;const row=await readOne(itemId,target.id,db(options));return row?toRow(row,target.locale):null},findManyByLanguageId:async(itemIds,languageId,options)=>{if(itemIds.length===0)return[];const rows=await db(options).select(fullSelection()).from(translationTable).where(and(inArray(itemColumn,[...itemIds]),eq(languageColumn,languageId)));const languages=await listContentLanguagesById(c,options?.tx);const locale=languages.get(languageId)?.locale??"";return rows.map(row=>toRow(row,locale))},findManyForItem:async(itemId,options)=>{const rows=await db(options).select(metaSelection()).from(translationTable).where(eq(itemColumn,itemId)).orderBy(asc(languageColumn));const languages=await listContentLanguagesById(c,options?.tx);return rows.map(row=>toMeta(row,languages.get(row.languageId)?.locale??""))},findManyRowsForItem:async(itemId,options)=>{const rows=await db(options).select(fullSelection()).from(translationTable).where(eq(itemColumn,itemId)).orderBy(asc(languageColumn));const languages=await listContentLanguagesById(c,options?.tx);return rows.map(row=>toRow(row,languages.get(row.languageId)?.locale??""))},publish:async(itemId,locale,options)=>await transition(itemId,locale,options??{},{guard:ne(statusColumn(),"published"),requireEnabled:true,values:{publishedAt:sql`coalesce(${columns.publishedAt}, now())`,status:"published"}}),resolveDefaultLanguage:async options=>await language(defaultLocale,{requireEnabled:true,tx:options?.tx}),resolveLanguage:async(locale,options)=>await language(locale,{requireEnabled:options?.requireEnabled??false,tx:options?.tx}),unpublish:async(itemId,locale,options)=>await transition(itemId,locale,options??{},{guard:eq(statusColumn(),"published"),requireEnabled:false,values:{status:"draft"}}),update:async(itemId,locale,values,options)=>{const target=await language(locale,{requireEnabled:true,tx:options.tx});const database=db(options);const parsed=schemas.update.parse(values);const patch=withUpdateSlugs(contentValuesToColumns(localizedFields,parsed));const current=await readOne(itemId,target.id,database);if(!current)return null;const changedColumns=diffChangedFields(localizedNames,current,patch);const changedFields=changedColumns.map(name=>pathByColumn.get(name)??name);if(changedFields.length===0){return{changed:false,changedFields,row:toRow(current,target.locale),version:versionOf(current)}}const[row]=await database.update(translationTable).set({...Object.fromEntries(changedColumns.map(key=>[key,patch[key]])),version:sql`${versionColumn} + 1`}).where(and(eq(itemColumn,itemId),eq(languageColumn,target.id),eq(versionColumn,options.expectedVersion))).returning(fullSelection());if(!row){const latest=await readOne(itemId,target.id,database);if(!latest)return null;throw new ContentTranslationVersionConflict({contentTypeId,currentVersion:versionOf(latest),expectedVersion:options.expectedVersion,itemId,locale:target.locale})}return{changed:true,changedFields,row:toRow(row,target.locale),version:versionOf(row)}}}};const listContentLanguagesById=async(c,tx)=>new Map((await listContentLanguages(c,tx)).map(language=>[language.id,language]));

package/dist/src/content/server/translation-routes.d.ts

@@ -0,0 +1,399 @@
+import { z } from "@hono/zod-openapi";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentModel } from "./model";
+export declare const buildContentTranslationRoutes: <TDefinition extends AnyContentTypeDefinition, P extends string>(model: ContentModel<TDefinition>, { pluginId }: {
+    pluginId: P;
+}) => (import("../../api/lib/route").Route<P, {
+    method: "get";
+    path: "/{id}/translations";
+    description: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodCoercedNumber;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}> | import("../../api/lib/route").Route<P, {
+    method: "get";
+    path: "/{id}/translations/{locale}";
+    description: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodCoercedNumber;
+            locale: z.ZodString;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+        404: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}> | import("../../api/lib/route").Route<P, {
+    method: "post";
+    path: "/{id}/translations/{locale}";
+    description: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodCoercedNumber;
+            locale: z.ZodString;
+        }, z.core.$strip>;
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+        };
+    };
+    responses: {
+        201: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+        404: {
+            description: string;
+        };
+        409: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}> | import("../../api/lib/route").Route<P, {
+    method: "put";
+    path: "/{id}/translations/{locale}";
+    description: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodCoercedNumber;
+            locale: z.ZodString;
+        }, z.core.$strip>;
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+        404: {
+            description: string;
+        };
+        409: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}> | import("../../api/lib/route").Route<P, {
+    method: "delete";
+    path: "/{id}/translations/{locale}";
+    description: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodCoercedNumber;
+            locale: z.ZodString;
+        }, z.core.$strip>;
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+        404: {
+            description: string;
+        };
+        409: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}> | import("../../api/lib/route").Route<P, {
+    method: "post";
+    path: "/{id}/translations/{locale}/publish" | "/{id}/translations/{locale}/unpublish";
+    description: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodCoercedNumber;
+            locale: z.ZodString;
+        }, z.core.$strip>;
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+        404: {
+            description: string;
+        };
+        409: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}> | import("../../api/lib/route").Route<P, {
+    method: "get";
+    path: "/{id}/translations/{locale}/revisions";
+    description: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodCoercedNumber;
+            locale: z.ZodString;
+        }, z.core.$strip>;
+        query: z.ZodObject<{
+            cursor: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            first: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+        404: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}> | import("../../api/lib/route").Route<P, {
+    method: "get";
+    path: "/{id}/translations/{locale}/revisions/{revisionId}";
+    description: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodCoercedNumber<unknown>;
+            locale: z.ZodString;
+            revisionId: z.ZodCoercedNumber<unknown>;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+        404: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}> | import("../../api/lib/route").Route<P, {
+    method: "post";
+    path: "/{id}/translations/{locale}/revisions/{revisionId}/restore";
+    description: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodCoercedNumber<unknown>;
+            locale: z.ZodString;
+            revisionId: z.ZodCoercedNumber<unknown>;
+        }, z.core.$strip>;
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+        404: {
+            description: string;
+        };
+        409: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+        422: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}> | import("../../api/lib/route").Route<P, {
+    method: "post";
+    path: "/{id}/translations/{locale}/preview";
+    description: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodCoercedNumber;
+            locale: z.ZodString;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+        404: {
+            description: string;
+        };
+        503: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}> | import("../../api/lib/route").Route<P, {
+    method: "get";
+    path: "/{id}/public-locales";
+    description: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodCoercedNumber;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>)[];
+//# sourceMappingURL=translation-routes.d.ts.map

package/dist/src/content/server/translation-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translation-routes.d.ts","sourceRoot":"","sources":["../../../../src/content/server/translation-routes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAGtC,OAAO,KAAK,EACV,wBAAwB,EAGzB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AA4D5C,eAAO,MAAM,6BAA6B,GACxC,WAAW,SAAS,wBAAwB,EAC5C,CAAC,SAAS,MAAM,EAEhB,OAAO,YAAY,CAAC,WAAW,CAAC,EAChC,cAAc;IAAE,QAAQ,EAAE,CAAC,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgzB9B,CAAC"}