@omerlo/omerlo-webkit 0.0.4 → 0.0.6

package/README.md

@@ -7,8 +7,6 @@ over all window's tab, no need to refresh other tabs.
 
 ## Using the omerlo webkit
 
-###
-
 Install the package `omerlo-webkit`
 
 ```sh
@@ -24,17 +22,17 @@ Copy the `.env.dist` to `.env` then update its values to match your Omerlo's app
 Create (or update) the file `src/hooks.server.ts` and add required hooks as follow
 
 ```ts
-import type { Handle } from "@sveltejs/kit";
+import type { Handle } from '@sveltejs/kit';
 
 import { handleUserToken, handleReaderApi } from 'omerlo-webkit/reader/server';
-import { sequence } from "@sveltejs/kit/hooks";
+import { sequence } from '@sveltejs/kit/hooks';
 
 // You can add custom hooks too
 const handleLocale: Handle = async ({ event, resolve }) => {
-    const userLocale = 'en'; // you can fetch this value from cookie or w.e
-    event.url.searchParams.append('locale', userLocale);
-    return resolve(event);
-}
+  const userLocale = 'en'; // you can fetch this value from cookie or w.e
+  event.url.searchParams.append('locale', userLocale);
+  return resolve(event);
+};
 
 export const handle = sequence(handleLocale, handleUserToken, handleReaderApi);
 ```
@@ -92,7 +90,7 @@ You'll need to create a login endpoint to add some required params such as the `
 
 ```ts
 // +server.ts
-import { error, redirect, type RequestHandler } from "@sveltejs/kit";
+import { error, redirect, type RequestHandler } from '@sveltejs/kit';
 import { env } from '$env/dynamic/private';
 import jwt from 'jsonwebtoken';
 
@@ -104,39 +102,41 @@ export const GET: RequestHandler = ({ url }) => {
   if (!oauthProviderId) error(400, 'Missing oauthProviderId query parameter');
 
   const currentPath = url.searchParams.get('currentPath') || '/';
-  const state = jwt.sign({ currentPath, oauthProviderId }, env.PRIVATE_JWT_SECRET, { expiresIn: '1h' })
+  const state = jwt.sign({ currentPath, oauthProviderId }, env.PRIVATE_JWT_SECRET, {
+    expiresIn: '1h'
+  });
 
   const redirectUrl = new URL(oauthUrl);
   redirectUrl.searchParams.set('state', state);
-  redirectUrl.searchParams.set('redirect_uri', url.origin +'/oauth/callback');
+  redirectUrl.searchParams.set('redirect_uri', url.origin + '/oauth/callback');
 
   redirect(302, redirectUrl);
-}
+};
 ```
 
 And then create a callback action.
 
 ```ts
-import { error, redirect, type RequestHandler } from "@sveltejs/kit";
+import { error, redirect, type RequestHandler } from '@sveltejs/kit';
 import { env } from '$env/dynamic/private';
 import jwt from 'jsonwebtoken';
-import { exchangeAuthorizationCode, setAuthorizationCookies } from "omerlo-webkit/reader/server";
+import { exchangeAuthorizationCode, setAuthorizationCookies } from 'omerlo-webkit/reader/server';
 
 export const GET: RequestHandler = async ({ url, cookies }) => {
   const redirectUri = url.origin + url.pathname;
   const state = getRequiredQueryParams(url, 'state');
   const code = getRequiredQueryParams(url, 'code');
-  const {oauthProviderId, currentPath} = parseJwt(state);
+  const { oauthProviderId, currentPath } = parseJwt(state);
 
   try {
-    const token = await exchangeAuthorizationCode({code, redirectUri, oauthProviderId})
+    const token = await exchangeAuthorizationCode({ code, redirectUri, oauthProviderId });
     setAuthorizationCookies(cookies, token);
-  } catch(_err) {
-    error(401, "Could not authenticate from the provider");
+  } catch (_err) {
+    error(401, 'Could not authenticate from the provider');
   }
 
   redirect(303, currentPath);
-}
+};
 
 function getRequiredQueryParams(url: URL, paramsName: string): string {
   const value = url.searchParams.get(paramsName);
@@ -149,14 +149,14 @@ function getRequiredQueryParams(url: URL, paramsName: string): string {
 }
 
 interface State {
-  oauthProviderId: string,
-  currentPath: string
+  oauthProviderId: string;
+  currentPath: string;
 }
 
 function parseJwt(state: string): State {
   try {
     return jwt.verify(state, env.PRIVATE_JWT_SECRET) as State;
-  } catch(_err) {
+  } catch (_err) {
     error(400, 'Invalid state');
   }
 }
@@ -168,13 +168,13 @@ To logout your user you can create an endpoint that will drop cookies used for a
 
 ```ts
 // +server.ts
-import { json, type RequestHandler } from "@sveltejs/kit";
+import { json, type RequestHandler } from '@sveltejs/kit';
 import { clearAuthorizationCookies } from 'omerlo-webkit/reader/server';
 
 export const DELETE: RequestHandler = ({ cookies }) => {
   clearAuthorizationCookies(cookies);
   return json(201);
-}
+};
 ```
 
 When a user is logout for any reason (401 or manually logout), the `invalidate('omerlo:user_session)` is triggered,

package/dist/components/OmerloWebkit.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
-  import { initUserSession, type UserSession } from "../omerlo/reader/stores/user_session";
-  import { onDestroy, onMount } from "svelte";
+  import { initUserSession, type UserSession } from '../omerlo/reader/stores/user_session';
+  import { onDestroy, onMount } from 'svelte';
 
   export let userSession: UserSession;
   let selfComponent: HTMLDivElement;
@@ -23,4 +23,3 @@
 <div id="omerlo-webkit" bind:this={selfComponent}>
   <slot></slot>
 </div>
-

package/dist/components/OmerloWebkit.svelte.d.ts

@@ -1,4 +1,4 @@
-import { type UserSession } from "../omerlo/reader/stores/user_session";
+import { type UserSession } from '../omerlo/reader/stores/user_session';
 interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
     new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
         $$bindings?: Bindings;

package/dist/omerlo/index.d.ts

@@ -1,12 +1,40 @@
 export declare const useReader: (f: typeof fetch) => {
     notifications: {
-        listTopics: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader/endpoints/notification").TopicSummary[]>>;
-        subscribeToTopic: (params: import("./reader/endpoints/notification").SubscribtionParams) => Promise<import("./reader/utils/api").ApiResponse<unknown>>;
-        unsubscribeFromTopic: (params: import("./reader/endpoints/notification").SubscribtionParams) => Promise<import("./reader/utils/api").ApiResponse<unknown>>;
+        listTopics: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").TopicSummary[]>>;
+        subscribeToTopic: (params: import("./reader").SubscriptionParams) => Promise<import("./reader/utils/api").ApiResponse<unknown>>;
+        unsubscribeFromTopic: (params: import("./reader").SubscriptionParams) => Promise<import("./reader/utils/api").ApiResponse<unknown>>;
     };
+    magazines: {
+        getIssue: (id: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Issue>>;
+        getBlocks: (sectionId: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").IssueBlock[]>>;
+        searchContents: (issueId: string, q: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").SectionContent[]>>;
+        getSectionContents: (sectionId: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Content[]>>;
+    };
+    getMenu: (key: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Menu>>;
+    listMenus: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").MenuSummary[]>>;
+    listOrganizations: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").OrganizationSummary[]>>;
+    getOrganization: () => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Organization>>;
+    getOrgWebpage: (slug: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").OrgWebpage>>;
+    listOrgWebpages: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").WebpageSummary[]>>;
+    getMedia: () => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Media>>;
+    getMediaOrganization: (id: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Organization>>;
+    listMediaOrganizations: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").OrganizationSummary[]>>;
+    getMediaEvent: (id: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Event>>;
+    listMediaEvents: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").EventSummary[]>>;
+    listMediaEventBlocks: (id: string, params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").ProfileBlockKind[]>>;
+    getMediaPerson: (id: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Person>>;
+    listMediaPersons: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").PersonSummary[]>>;
+    getMediaProject: (id: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Project>>;
+    listMediaProjects: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").ProjectSummary[]>>;
+    getMediaProfileType: (id: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").ProfileType>>;
+    listMediaProfileTypes: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").ProfileTypeSummary[]>>;
+    getContent: (id: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Content>>;
+    listContents: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").ContentSummary[]>>;
+    listCategories: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Category[]>>;
+    getCategory: (id: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Category>>;
     listOauthProviders: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").OauthProviderSummary[]>>;
     getOauthUser: () => Promise<import("./reader/utils/api").ApiResponse<import("./reader").OauthUser>>;
-    registerDevice: (params: import("./reader/endpoints/device").DeviceParams) => Promise<import("./reader/utils/api").ApiResponse<unknown>>;
+    registerDevice: (params: import("./reader").DeviceParams) => Promise<import("./reader/utils/api").ApiResponse<unknown>>;
     userInfo: () => Promise<import("./reader/utils/api").ApiResponse<import("./reader").UserInfo>>;
     verifyAccount: (params: import("./reader").VerifyAccountParams) => void;
     validateAccount: (params: import("./reader").ValidateAccountParams) => void;

package/dist/omerlo/reader/endpoints/categories.d.ts

@@ -0,0 +1,18 @@
+import { type LocalesMetadata } from '../utils/response';
+import { type ApiAssocs, type ApiData, type PagingParams } from '../utils/api';
+export declare const categoriesFetchers: (f: typeof fetch) => {
+    listCategories: (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<Category[]>>;
+    getCategory: (id: string) => Promise<import("../utils/api").ApiResponse<Category>>;
+};
+export interface Category {
+    id: string;
+    svg: string;
+    name: string;
+    meta: {
+        locales: LocalesMetadata;
+    };
+    updatedAt: Date;
+}
+export declare function getCategory(f: typeof fetch): (id: string) => Promise<import("../utils/api").ApiResponse<Category>>;
+export declare function listCategories(f: typeof fetch): (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<Category[]>>;
+export declare function parseCategory(data: ApiData, _assoc: ApiAssocs): Category;

package/dist/omerlo/reader/endpoints/categories.js

@@ -0,0 +1,39 @@
+import { parseLocalesMetadata } from '../utils/response';
+import { parseMany } from '../utils/api';
+import { requestPublisher } from '../utils/request';
+import { buildMeta } from '../utils/parseHelpers';
+export const categoriesFetchers = (f) => {
+    return {
+        listCategories: listCategories(f),
+        getCategory: getCategory(f)
+    };
+};
+export function getCategory(f) {
+    return async (id) => {
+        const opts = { parser: parseCategory };
+        return requestPublisher(f, `media/categories/${id}`, opts);
+    };
+}
+export function listCategories(f) {
+    return async (params) => {
+        const opts = { parser: parseMany(parseCategory), queryParams: params };
+        return requestPublisher(f, `media/categories`, opts);
+    };
+}
+export function parseCategory(data, _assoc) {
+    let meta;
+    // NOTE: this is to support publisher public api v2 but also reader api v1
+    if (data.meta) {
+        meta = { locales: parseLocalesMetadata(data.meta) };
+    }
+    else {
+        meta = buildMeta(data.localized.locale);
+    }
+    return {
+        id: data.id,
+        name: data.name,
+        svg: data.svg_icon,
+        meta,
+        updatedAt: data.updated_at
+    };
+}

package/dist/omerlo/reader/endpoints/content-templates.d.ts

@@ -0,0 +1,23 @@
+import { type LocalesMetadata } from '../utils/response';
+import type { ApiAssocs, ApiData } from '../utils/api';
+export interface ContentTemplate {
+    id: string;
+    key: string;
+    name: string;
+    meta: {
+        locales: LocalesMetadata;
+    };
+    metadata: Record<string, string>;
+    enabledFields: string[];
+    updatedAt: Date;
+}
+export interface ContentBlockTemplate {
+    id: string;
+    key: string;
+    visual: {
+        allowedTypes: string[];
+        isEnabled: boolean;
+    };
+}
+export declare function parseContentBlockTemplate(data: ApiData, _assocs: ApiAssocs): ContentBlockTemplate;
+export declare function parseContentTemplate(data: ApiData, _assocs: ApiAssocs): ContentTemplate;

package/dist/omerlo/reader/endpoints/content-templates.js

@@ -0,0 +1,34 @@
+import { parseLocalesMetadata } from '../utils/response';
+import { buildMeta } from '../utils/parseHelpers';
+export function parseContentBlockTemplate(data, _assocs) {
+    return {
+        id: data.id,
+        key: data.key,
+        visual: {
+            allowedTypes: data.visual.allowed_types,
+            isEnabled: data.visual.is_enabled
+        }
+    };
+}
+export function parseContentTemplate(data, _assocs) {
+    let name;
+    let meta;
+    if (data.localized) {
+        // NOTE: this is for retrocompatibility with public publisher api v2
+        name = data.localized.name;
+        meta = buildMeta(data.localized.locale);
+    }
+    else {
+        name = data.name;
+        meta = { locales: parseLocalesMetadata(data.meta) };
+    }
+    return {
+        id: data.id,
+        key: data.key,
+        name,
+        meta,
+        metadata: data.metadata,
+        enabledFields: data.enabled_fields,
+        updatedAt: data.updated_at
+    };
+}

package/dist/omerlo/reader/endpoints/contents.d.ts

@@ -0,0 +1,122 @@
+import type { Category } from './categories';
+import type { ContentBlockTemplate, ContentTemplate } from './content-templates';
+import { type Visual, type Slideshow, type Image, type Video } from './visuals';
+import { type ApiAssocs, type ApiData, type PagingParams } from '../utils/api';
+import { type LocalesMetadata } from '../utils/response';
+import type { PersonSummary } from './person';
+import type { OrganizationSummary } from './organizations';
+export declare const contentsFetchers: (f: typeof fetch) => {
+    getContent: (id: string) => Promise<import("../utils/api").ApiResponse<Content>>;
+    listContents: (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<ContentSummary[]>>;
+};
+export interface ContentSeo {
+    title: string;
+    description: string;
+}
+export interface ContentSummary {
+    id: string;
+    template: ContentTemplate;
+    canonicalDomain: string | null;
+    canonicalUrl: string | null;
+    publishedAt: Date | null;
+    visibility: string | null;
+    categories: Category[];
+    showPublishedAt: boolean;
+    updatedAt: Date;
+    titleHtml: string;
+    titleText: string;
+    leadHtml: string | null;
+    leadText: string | null;
+    subtitleHtml: string | null;
+    subtitleText: string | null;
+    visual: Visual | null;
+    meta: {
+        locales: LocalesMetadata;
+    };
+    authors: (PersonSummary | OrganizationSummary)[];
+}
+export interface Content extends ContentSummary {
+    metadata: Record<string, string>;
+    blocks: ContentBlock[];
+}
+export type ContentBlockRichtext = {
+    id: string;
+    kind: 'richtext';
+    contentHtml: string;
+    visual: Visual | null;
+    template: ContentBlockTemplate | null;
+};
+export type ContentBlockData = {
+    id: string;
+    kind: 'data';
+    contentType: string;
+    data: string;
+    visual: Visual | null;
+    template: ContentBlockTemplate | null;
+};
+export type ContentBlockHTML = {
+    id: string;
+    kind: 'html';
+    contentHtml: string;
+    visual: Visual | null;
+    template: ContentBlockTemplate | null;
+};
+export type ContentBlockQuote = {
+    id: string;
+    kind: 'quote';
+    quoteHtml: string;
+    quoteText: string;
+    author: string;
+    visual: Visual | null;
+    template: ContentBlockTemplate | null;
+};
+export type ContentBlockRelatedContents = {
+    id: string;
+    kind: 'related-contents';
+    contents: Content[];
+    visual: Visual | null;
+    template: ContentBlockTemplate | null;
+};
+export type Answer = {
+    id: string;
+    contentHtml: string;
+    contentText: string;
+};
+export type ContentBlockQuestion = {
+    id: string;
+    kind: 'question';
+    questionHtml: string;
+    questionText: string;
+    acceptVoteUntil: Date;
+    answers: Answer[];
+    visual: Visual | null;
+    template: ContentBlockTemplate | null;
+};
+export type ContentBlockImage = {
+    id: string;
+    kind: 'image';
+    image: Image;
+    visual: Visual | null;
+    template: ContentBlockTemplate | null;
+};
+export type ContentBlockSlideshow = {
+    id: string;
+    kind: 'slideshow';
+    slideshow: Slideshow;
+    visual: Visual | null;
+    template: ContentBlockTemplate | null;
+};
+export type ContentBlockVideo = {
+    id: string;
+    kind: 'video';
+    video: Video;
+    visual: Visual | null;
+    template: ContentBlockTemplate | null;
+};
+export type ContentBlock = ContentBlockRichtext | ContentBlockData | ContentBlockHTML | ContentBlockQuote | ContentBlockRelatedContents | ContentBlockQuestion | ContentBlockImage | ContentBlockSlideshow | ContentBlockVideo;
+export type ContentBlockType = 'richtext' | 'data' | 'html' | 'quote' | 'related-contents' | 'question' | 'image' | 'slideshow' | 'video';
+export declare function getContent(f: typeof fetch): (id: string) => Promise<import("../utils/api").ApiResponse<Content>>;
+export declare function listContents(f: typeof fetch): (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<ContentSummary[]>>;
+export declare function parseContentSummary(data: ApiData, assocs: ApiAssocs): ContentSummary;
+export declare function parseContent(data: ApiData, assocs: ApiAssocs): Content;
+export declare function parseContentBlock(block: ApiData, assocs: ApiAssocs): ContentBlock | null;

package/dist/omerlo/reader/endpoints/contents.js

@@ -0,0 +1,187 @@
+import { parseVideo, parseImage, parseSlideshow, parseVisual } from './visuals';
+import { requestPublisher } from '../utils/request';
+import { parseMany } from '../utils/api';
+import { getAssoc, getAssocs } from '../utils/assocs';
+import { parseLocalesMetadata } from '../utils/response';
+import { buildMeta, parseDate } from '../utils/parseHelpers';
+export const contentsFetchers = (f) => {
+    return {
+        getContent: getContent(f),
+        listContents: listContents(f)
+    };
+};
+function baseBlock(data, assocs) {
+    return {
+        id: data.id,
+        kind: data.kind,
+        template: getBlockTemplate(data, assocs),
+        visual: parseVisual(data.visual, assocs)
+    };
+}
+export function getContent(f) {
+    return async (id) => {
+        const opts = { parser: parseContent };
+        return requestPublisher(f, `media/contents/${id}`, opts);
+    };
+}
+export function listContents(f) {
+    return async (params) => {
+        const opts = { parser: parseMany(parseContentSummary), queryParams: params };
+        return requestPublisher(f, `media/contents`, opts);
+    };
+}
+export function parseContentSummary(data, assocs) {
+    if (data.localized) {
+        // NOTE: This is to support publisher public api v2
+        return {
+            id: data.id,
+            template: getAssoc(assocs, 'templates', data.template_id),
+            canonicalDomain: data.canonical_domain,
+            canonicalUrl: data.canonical_url,
+            publishedAt: parseDate(data.published_at),
+            visibility: data.visibility,
+            categories: getAssocs(assocs, 'categories', data.category_ids),
+            showPublishedAt: data.show_published_at,
+            updatedAt: new Date(data.updated_at),
+            titleHtml: data.localized.title_html,
+            titleText: data.localized.title_text,
+            leadHtml: data.localized.lead_html,
+            leadText: data.localized.lead_text,
+            subtitleHtml: data.localized.subtitle_html,
+            subtitleText: data.localized.subtitle_text,
+            visual: parseVisual(data.visual, assocs),
+            meta: buildMeta(data.localized.locale),
+            authors: getAssocs(assocs, 'profiles', data.localized.author_ids)
+        };
+    }
+    else {
+        return {
+            id: data.id,
+            template: getAssoc(assocs, 'content_templates', data.template_id),
+            canonicalDomain: data.canonical_domain,
+            canonicalUrl: data.canonical_url,
+            publishedAt: parseDate(data.published_at),
+            visibility: data.visibility,
+            categories: getAssocs(assocs, 'categories', data.category_ids),
+            showPublishedAt: data.show_published_at,
+            updatedAt: new Date(data.updated_at),
+            titleHtml: data.title_html,
+            titleText: data.title_text,
+            leadHtml: data.lead_html,
+            leadText: data.lead_text,
+            subtitleHtml: data.subtitle_html,
+            subtitleText: data.subtitle_text,
+            visual: parseVisual(data.visual, assocs),
+            meta: { locales: parseLocalesMetadata(data.meta) },
+            authors: getAssocs(assocs, 'profiles', data.author_ids)
+        };
+    }
+}
+export function parseContent(data, assocs) {
+    let seo;
+    if (data.localized) {
+        seo = { title: data.localized.seo.title, description: data.localized.seo.description };
+    }
+    else {
+        seo = { title: data.seo.title, description: data.seo.description };
+    }
+    return {
+        ...parseContentSummary(data, assocs),
+        metadata: data.metadata,
+        seo,
+        blocks: data.localized.blocks
+            .map((block) => parseContentBlock(block, assocs))
+            .filter(Boolean)
+    };
+}
+const ContentBlockParser = {
+    richtext: parseContentBlockRichtext,
+    data: parseContentBlockData,
+    html: parseContentBlockHTML,
+    quote: parseContentBlockQuote,
+    'related-contents': parseContentBlockRelatedContents,
+    question: parseContentBlockQuestion,
+    image: parseContentBlockImage,
+    slideshow: parseContentBlockSlideshow,
+    video: parseContentBlockVideo
+};
+export function parseContentBlock(block, assocs) {
+    const parser = ContentBlockParser[block.kind];
+    return parser ? parser(block, assocs) : null;
+}
+function getBlockTemplate(data, assocs) {
+    return data.template_id
+        ? getAssoc(assocs, 'block_templates', data.template_id)
+        : null;
+}
+function getBlockContent(data, assocs) {
+    return data.related_contents ? getAssocs(assocs, 'contents', data.related_contents) : [];
+}
+function parseContentBlockRichtext(data, assocs) {
+    return {
+        ...baseBlock(data, assocs),
+        contentHtml: data.content_html
+    };
+}
+function parseContentBlockData(data, assocs) {
+    return {
+        ...baseBlock(data, assocs),
+        contentType: data.content_type,
+        data: data.data
+    };
+}
+function parseContentBlockHTML(data, assocs) {
+    return {
+        ...baseBlock(data, assocs),
+        contentHtml: data.content_html
+    };
+}
+function parseContentBlockQuote(data, assocs) {
+    return {
+        ...baseBlock(data, assocs),
+        quoteHtml: data.quote_html,
+        quoteText: data.quote_text,
+        author: data.author
+    };
+}
+function parseContentBlockRelatedContents(data, assocs) {
+    const contents = getBlockContent(data, assocs);
+    return {
+        ...baseBlock(data, assocs),
+        contents
+    };
+}
+function parseContentBlockQuestion(data, assocs) {
+    return {
+        ...baseBlock(data, assocs),
+        questionHtml: data.question_html,
+        questionText: data.question_text,
+        acceptVoteUntil: new Date(data.accept_vote_until),
+        answers: data.answers?.map((answer) => parseAnswer(answer)) || []
+    };
+}
+function parseAnswer(data) {
+    return {
+        id: data.id,
+        contentHtml: data.content_html,
+        contentText: data.content_text
+    };
+}
+function parseContentBlockImage(data, assocs) {
+    return {
+        ...baseBlock(data, assocs),
+        image: parseImage(data.image, assocs)
+    };
+}
+function parseContentBlockSlideshow(data, assocs) {
+    return {
+        ...baseBlock(data, assocs),
+        slideshow: parseSlideshow(data.slideshow, assocs)
+    };
+}
+function parseContentBlockVideo(data, assocs) {
+    return {
+        ...baseBlock(data, assocs),
+        video: parseVideo(data.video, assocs)
+    };
+}

package/dist/omerlo/reader/endpoints/device.js

@@ -1,7 +1,7 @@
 import { request } from '../utils/request';
 export const deviceFetchers = (f) => {
     return {
-        registerDevice: registerDevice(f),
+        registerDevice: registerDevice(f)
     };
 };
 export function registerDevice(f) {

package/dist/omerlo/reader/endpoints/events.d.ts

@@ -0,0 +1,32 @@
+import type { Category } from './categories';
+import { type ApiAssocs, type ApiData } from '../utils/api';
+import type { LocalesMetadata } from '../utils/response';
+import type { ProfileType } from './profileType';
+import type { ProfileAddress, ProfileContact, ProfileDescription } from './profiles';
+export interface EventSummary {
+    id: string;
+    profileType: ProfileType;
+    kind: string;
+    type: string;
+    isAllDay: boolean;
+    profileImageURL: string | null;
+    coverImageURL: string | null;
+    subscriptionURL: string | null;
+    meta: {
+        locales: LocalesMetadata;
+    };
+    name: string | null;
+    summaryHtml: string | null;
+    summaryText: string | null;
+    startsAt: Date | null;
+    endsAt: Date | null;
+    updatedAt: Date;
+}
+export interface Event extends EventSummary {
+    categories: Category[];
+    address: ProfileAddress | null;
+    contact: ProfileContact | null;
+    description: ProfileDescription | null;
+}
+export declare function parseEventSummary(data: ApiData, assocs: ApiAssocs): EventSummary;
+export declare function parseEvent(data: ApiData, assocs: ApiAssocs): Event;