@liase/core 1.0.0

package/dist/plugins/built-in-sources/bluesky/requestHandlers/singleMedia.d.ts

@@ -0,0 +1,351 @@
+import { z } from "zod";
+declare const _default: {
+    readonly id: "single-media";
+    readonly displayName: "Single media";
+    readonly description: "Find a specific media included in a post";
+    readonly requestSchema: z.ZodObject<{
+        source: z.ZodString;
+        queryType: z.ZodString;
+        id: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        source: string;
+        queryType: string;
+        id: string;
+    }, {
+        source: string;
+        queryType: string;
+        id: string;
+    }>;
+    readonly secretsSchema: z.ZodObject<{
+        handle: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        serviceUrl: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        password?: string | undefined;
+        handle?: string | undefined;
+        serviceUrl?: string | undefined;
+    }, {
+        password?: string | undefined;
+        handle?: string | undefined;
+        serviceUrl?: string | undefined;
+    }>;
+    readonly paginationType: "none";
+    readonly responses: [{
+        readonly schema: z.ZodObject<Omit<{
+            page: z.ZodObject<{
+                paginationType: z.ZodLiteral<"cursor">;
+                cursor: z.ZodOptional<z.ZodString>;
+                nextCursor: z.ZodNullable<z.ZodString>;
+                isLastPage: z.ZodBoolean;
+                pageFetchLimitReached: z.ZodBoolean;
+            }, "strict", z.ZodTypeAny, {
+                paginationType: "cursor";
+                isLastPage: boolean;
+                pageFetchLimitReached: boolean;
+                nextCursor: string | null;
+                cursor?: string | undefined;
+            }, {
+                paginationType: "cursor";
+                isLastPage: boolean;
+                pageFetchLimitReached: boolean;
+                nextCursor: string | null;
+                cursor?: string | undefined;
+            }>;
+            media: z.ZodArray<z.ZodObject<{
+                mediaFinderSource: z.ZodLiteral<"bluesky">;
+                id: z.ZodString;
+                title: z.ZodString;
+                url: z.ZodString;
+                dateUploaded: z.ZodDate;
+                usernameOfUploader: z.ZodString;
+                nameOfUploader: z.ZodString;
+                files: z.ZodTuple<[z.ZodObject<{
+                    url: z.ZodString;
+                    ext: z.ZodString;
+                    mimeType: z.ZodString;
+                    image: z.ZodBoolean;
+                    video: z.ZodBoolean;
+                    fileSize: z.ZodOptional<z.ZodNumber>;
+                    aspectRatio: z.ZodOptional<z.ZodObject<{
+                        height: z.ZodNumber;
+                        width: z.ZodNumber;
+                    }, "strict", z.ZodTypeAny, {
+                        width: number;
+                        height: number;
+                    }, {
+                        width: number;
+                        height: number;
+                    }>>;
+                } & {
+                    type: z.ZodLiteral<"full">;
+                }, "strict", z.ZodTypeAny, {
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "full";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }, {
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "full";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }>, z.ZodObject<{
+                    url: z.ZodString;
+                    ext: z.ZodString;
+                    mimeType: z.ZodString;
+                    image: z.ZodBoolean;
+                    video: z.ZodBoolean;
+                    fileSize: z.ZodOptional<z.ZodNumber>;
+                    aspectRatio: z.ZodOptional<z.ZodObject<{
+                        height: z.ZodNumber;
+                        width: z.ZodNumber;
+                    }, "strict", z.ZodTypeAny, {
+                        width: number;
+                        height: number;
+                    }, {
+                        width: number;
+                        height: number;
+                    }>>;
+                } & {
+                    type: z.ZodLiteral<"thumbnail">;
+                }, "strict", z.ZodTypeAny, {
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "thumbnail";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }, {
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "thumbnail";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }>], null>;
+                contentHash: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                url: string;
+                id: string;
+                contentHash: string;
+                mediaFinderSource: "bluesky";
+                files: [{
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "full";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }, {
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "thumbnail";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }];
+                nameOfUploader: string;
+                usernameOfUploader: string;
+                title: string;
+                dateUploaded: Date;
+            }, {
+                url: string;
+                id: string;
+                contentHash: string;
+                mediaFinderSource: "bluesky";
+                files: [{
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "full";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }, {
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "thumbnail";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }];
+                nameOfUploader: string;
+                usernameOfUploader: string;
+                title: string;
+                dateUploaded: Date;
+            }>, "many">;
+            request: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "page">, "strict", z.ZodTypeAny, {
+            media: {
+                url: string;
+                id: string;
+                contentHash: string;
+                mediaFinderSource: "bluesky";
+                files: [{
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "full";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }, {
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "thumbnail";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }];
+                nameOfUploader: string;
+                usernameOfUploader: string;
+                title: string;
+                dateUploaded: Date;
+            }[];
+            request: Record<string, unknown>;
+        }, {
+            media: {
+                url: string;
+                id: string;
+                contentHash: string;
+                mediaFinderSource: "bluesky";
+                files: [{
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "full";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }, {
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "thumbnail";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }];
+                nameOfUploader: string;
+                usernameOfUploader: string;
+                title: string;
+                dateUploaded: Date;
+            }[];
+            request: Record<string, unknown>;
+        }>;
+        readonly constructor: {
+            readonly _setup: ($: import("../../../../ActionContext.js").ActionContext) => Promise<import("@atproto/api/dist/client/types/app/bsky/feed/getPosts.js").OutputSchema>;
+            readonly media: {
+                _arrayMap: ($: import("../../../../ActionContext.js").ActionContext) => {
+                    id: string;
+                    postCid: string;
+                    postUri: string;
+                    postUrl: string;
+                    postTextContents: string;
+                    fileCid: string;
+                    altText: string;
+                    mimeType: string;
+                    filesize: number;
+                    playlistUrl?: string;
+                    thumbnailUrl: string;
+                    fullsizeUrl?: string;
+                    aspectRatio: {
+                        width: number;
+                        height: number;
+                    };
+                    author: {
+                        did: string;
+                        handle: string;
+                        displayName: string;
+                        avatarUrl: string;
+                        createdAt: string;
+                    };
+                    languages: string[];
+                    createdAt: string;
+                }[];
+                mediaFinderSource: string;
+                id: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                contentHash: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                title: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                url: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                dateUploaded: ($: import("../../../../ActionContext.js").ActionContext) => Date;
+                usernameOfUploader: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                nameOfUploader: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                files: {
+                    _arrayMap: ($: import("../../../../ActionContext.js").ActionContext) => any[];
+                    _setup: ($: import("../../../../ActionContext.js").ActionContext) => import("../../../../ActionContext.js").ActionContext;
+                    type: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                    url: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                    ext: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                    mimeType: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                    image: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                    video: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                    fileSize: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                    aspectRatio: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                }[];
+            }[];
+            readonly request: ($: import("../../../../ActionContext.js").ActionContext) => Record<string, any>;
+        };
+    }];
+};
+export default _default;
+//# sourceMappingURL=singleMedia.d.ts.map

package/dist/plugins/built-in-sources/bluesky/requestHandlers/singleMedia.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleMedia.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/built-in-sources/bluesky/requestHandlers/singleMedia.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOxB,wBAkDoC"}

package/dist/plugins/built-in-sources/bluesky/requestHandlers/singleMedia.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { getAgent } from "../client.js";
+import { postsToMediaResponseConstructor } from "../shared.js";
+import { responseSchema } from "../types.js";
+export default {
+    id: "single-media",
+    displayName: "Single media",
+    description: "Find a specific media included in a post",
+    requestSchema: z
+        .object({
+        source: z.string(),
+        queryType: z.string(),
+        id: z.string(),
+    })
+        .strict(),
+    secretsSchema: z
+        .object({
+        handle: z.string().optional(),
+        password: z.string().optional(),
+        serviceUrl: z.string().optional(),
+    })
+        .strict(),
+    paginationType: "none",
+    responses: [
+        {
+            schema: responseSchema.omit({ page: true }),
+            constructor: {
+                _setup: async ($) => {
+                    let res;
+                    try {
+                        const agent = await getAgent({
+                            $,
+                            handle: $.secrets.handle,
+                            password: $.secrets.password,
+                            serviceUrl: $.secrets.serviceUrl,
+                        });
+                        const apiRes = await agent.app.bsky.feed.getPosts({
+                            uris: [$.request.id.replace(/#\w+$/, "")],
+                        });
+                        res = apiRes;
+                        if (!apiRes.success) {
+                            throw Error("Unsuccessful request to Bluesky");
+                        }
+                        return apiRes.data;
+                    }
+                    catch (error) {
+                        console.info("Response:", res);
+                        throw error;
+                    }
+                },
+                media: postsToMediaResponseConstructor,
+                request: ($) => $.request,
+            },
+        },
+    ],
+};

package/dist/plugins/built-in-sources/bluesky/shared.d.ts

@@ -0,0 +1,53 @@
+export declare const sourceId = "bluesky";
+export declare const postsToMediaResponseConstructor: {
+    _arrayMap: ($: import("../../../ActionContext.js").ActionContext) => BlueskyMedia[];
+    mediaFinderSource: string;
+    id: ($: import("../../../ActionContext.js").ActionContext) => any;
+    contentHash: ($: import("../../../ActionContext.js").ActionContext) => any;
+    title: ($: import("../../../ActionContext.js").ActionContext) => any;
+    url: ($: import("../../../ActionContext.js").ActionContext) => any;
+    dateUploaded: ($: import("../../../ActionContext.js").ActionContext) => Date;
+    usernameOfUploader: ($: import("../../../ActionContext.js").ActionContext) => any;
+    nameOfUploader: ($: import("../../../ActionContext.js").ActionContext) => any;
+    files: {
+        _arrayMap: ($: import("../../../ActionContext.js").ActionContext) => any[];
+        _setup: ($: import("../../../ActionContext.js").ActionContext) => import("../../../ActionContext.js").ActionContext;
+        type: ($: import("../../../ActionContext.js").ActionContext) => any;
+        url: ($: import("../../../ActionContext.js").ActionContext) => any;
+        ext: ($: import("../../../ActionContext.js").ActionContext) => any;
+        mimeType: ($: import("../../../ActionContext.js").ActionContext) => any;
+        image: ($: import("../../../ActionContext.js").ActionContext) => any;
+        video: ($: import("../../../ActionContext.js").ActionContext) => any;
+        fileSize: ($: import("../../../ActionContext.js").ActionContext) => any;
+        aspectRatio: ($: import("../../../ActionContext.js").ActionContext) => any;
+    }[];
+}[];
+type BlueskyMedia = {
+    id: string;
+    postCid: string;
+    postUri: string;
+    postUrl: string;
+    postTextContents: string;
+    fileCid: string;
+    altText: string;
+    mimeType: string;
+    filesize: number;
+    playlistUrl?: string;
+    thumbnailUrl: string;
+    fullsizeUrl?: string;
+    aspectRatio: {
+        width: number;
+        height: number;
+    };
+    author: {
+        did: string;
+        handle: string;
+        displayName: string;
+        avatarUrl: string;
+        createdAt: string;
+    };
+    languages: string[];
+    createdAt: string;
+};
+export {};
+//# sourceMappingURL=shared.d.ts.map

package/dist/plugins/built-in-sources/bluesky/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/plugins/built-in-sources/bluesky/shared.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ,YAAY,CAAC;AAElC,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;GAgErB,CAAC;AAExB,KAAK,YAAY,GAAG;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE;QACX,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,MAAM,EAAE;QACN,GAAG,EAAE,MAAM,CAAC;QACZ,MAAM,EAAE,MAAM,CAAC;QACf,WAAW,EAAE,MAAM,CAAC;QACpB,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC"}

package/dist/plugins/built-in-sources/bluesky/shared.js

@@ -0,0 +1,127 @@
+export const sourceId = "bluesky";
+export const postsToMediaResponseConstructor = [
+    {
+        _arrayMap: ($) => postsToMedia(
+        // biome-ignore lint/suspicious/noExplicitAny: bluesky API response is untyped
+        $().posts ?? $().feed?.map((item) => item.post) ?? []).filter((bskyMedia) => $.request.id ? bskyMedia.id === $.request.id : true),
+        mediaFinderSource: sourceId,
+        id: ($) => $().id,
+        contentHash: ($) => $().fileCid,
+        title: ($) => $().postTextContents,
+        url: ($) => $().postUrl,
+        dateUploaded: ($) => new Date($().createdAt),
+        usernameOfUploader: ($) => $().author.handle,
+        nameOfUploader: ($) => $().author.displayName,
+        files: [
+            {
+                _arrayMap: ($) => [
+                    ...($().fullsizeUrl
+                        ? [{ ...$(), url: $().fullsizeUrl, mediaFinderType: "full" }]
+                        : []),
+                    ...($().playlistUrl
+                        ? [{ ...$(), url: $().playlistUrl, mediaFinderType: "full" }]
+                        : []),
+                    ...($().thumbnailUrl
+                        ? [
+                            {
+                                url: $().thumbnailUrl,
+                                mediaFinderType: "thumbnail",
+                                // For image posts use the image mimeType; for video posts the
+                                // thumbnail is always a JPEG image regardless of video format
+                                mimeType: $().fullsizeUrl ? $().mimeType : "image/jpeg",
+                            },
+                        ]
+                        : []),
+                ],
+                _setup: ($) => $.set("mediaInfo", $.guessMediaInfoFromUrl(
+                // Bluesky CDN URLs previously had a @format suffix (e.g. @jpeg).
+                // Keep this replacement for backward-compat with cached responses.
+                $().url.replace(/@(\w+)$/, (_, match) => `.${match}`), 
+                // Fall back to the mimeType stored on the entry when the URL has
+                // no file extension (current Bluesky CDN image URL format).
+                { mimeType: $().mimeType })),
+                type: ($) => $().mediaFinderType,
+                url: ($) => $().url,
+                ext: ($) => $("mediaInfo").ext,
+                mimeType: ($) => $("mediaInfo").mimeType,
+                image: ($) => $("mediaInfo").image,
+                video: ($) => $("mediaInfo").video,
+                fileSize: ($) => $().filesize,
+                aspectRatio: ($) => $().aspectRatio,
+            },
+        ],
+    },
+];
+// biome-ignore lint/suspicious/noExplicitAny: bluesky API response is untyped
+function postsToMedia(posts) {
+    const mediaPosts = [];
+    for (const post of posts) {
+        const media = [];
+        const postUrl = `https://bsky.app/profile/${post.uri.split("/").at(2)}/post/${post.uri.split("/").at(-1)}`;
+        if (post.record.embed?.images && post.embed?.images) {
+            if (post.record.embed.images.length !== post.embed.images.length) {
+                throw Error();
+            }
+            for (let i = 0; i < post.embed.images.length; i++) {
+                const fileCid = post.record.embed.images[i].image.ref.toString();
+                media.push({
+                    id: `${post.uri}#${fileCid}`,
+                    languages: post.record.langs,
+                    createdAt: post.record.createdAt,
+                    author: {
+                        did: post.author.did,
+                        handle: post.author.handle,
+                        displayName: post.author.displayName,
+                        avatarUrl: post.author.avatar,
+                        createdAt: post.author.createdAt,
+                    },
+                    altText: post.embed.images[i].alt,
+                    fileCid,
+                    postCid: post.cid,
+                    postUri: post.uri,
+                    postTextContents: post.record.text,
+                    mimeType: post.record.embed.images[i].image.mimeType,
+                    filesize: post.record.embed.images[i].image.size,
+                    fullsizeUrl: post.embed.images[i].fullsize,
+                    thumbnailUrl: post.embed.images[i].thumb,
+                    aspectRatio: post.embed.images[i].aspectRatio && {
+                        width: post.embed.images[i].aspectRatio.width,
+                        height: post.embed.images[i].aspectRatio.height,
+                    },
+                    postUrl,
+                });
+            }
+        }
+        else if (post.record.embed?.video) {
+            const fileCid = post.record.embed.video.ref.toString();
+            media.push({
+                id: `${post.uri}#${fileCid}`,
+                languages: post.record.langs,
+                createdAt: post.record.createdAt,
+                fileCid,
+                postCid: post.cid,
+                postUri: post.uri,
+                postTextContents: post.record.text,
+                mimeType: post.record.embed.video.mimeType,
+                filesize: post.record.embed.video.size,
+                playlistUrl: post.embed?.playlist,
+                thumbnailUrl: post.embed?.thumbnail,
+                aspectRatio: post.embed?.aspectRatio && {
+                    width: post.embed?.aspectRatio.width,
+                    height: post.embed?.aspectRatio.height,
+                },
+                author: {
+                    did: post.author.did,
+                    handle: post.author.handle,
+                    displayName: post.author.displayName,
+                    avatarUrl: post.author.avatar,
+                    createdAt: post.author.createdAt,
+                },
+                altText: post.embed?.alt,
+                postUrl,
+            });
+        }
+        mediaPosts.push(media);
+    }
+    return mediaPosts.flat();
+}