@alpaca-editor/core 1.0.3942 → 1.0.3943

package/src/editor/services/componentDesignerService.ts

@@ -0,0 +1,151 @@
+import { InsertOption, Rendering } from "../../types";
+import { ItemDescriptor } from "../pageModel";
+import { getItemDescriptor } from "../utils";
+import { post } from "./serviceHelper";
+
+export async function createNewComponent(
+  name: string,
+  contextItem: ItemDescriptor
+): Promise<string | Error> {
+  let url = "/alpaca/headless/component/create";
+
+  const response = await post(url, {
+    name,
+    contextItem: getItemDescriptor(contextItem),
+  });
+
+  if (!response.response.ok) {
+    return new Error("Error creating new component");
+  }
+
+  return await response.response.json();
+}
+
+export async function createRendering(
+  name: string,
+  context: ItemDescriptor,
+  componentTemplateId: string
+): Promise<{ id: string } | Error> {
+  let url = "/alpaca/headless/component/createRendering";
+
+  const response = await post(url, {
+    contextItem: getItemDescriptor(context),
+    componentTemplateId,
+    name,
+  });
+
+  if (!response.response.ok) {
+    return new Error("Error creating new rendering");
+  }
+
+  return await response.response.json();
+}
+
+export async function getAllComponents(
+  contextItemId: string
+): Promise<Array<Component>> {
+  let url = "/alpaca/headless/component/all?contextItemId=" + contextItemId;
+
+  const response = await fetch(url, {
+    method: "GET",
+    credentials: "include",
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+
+  return await response.json();
+}
+
+export async function getFieldTypes(): Promise<Array<FieldTypeGroup>> {
+  let url = "/alpaca/headless/component/fieldtypes";
+
+  const response = await fetch(url, {
+    method: "GET",
+    credentials: "include",
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+
+  return await response.json();
+}
+
+export type Component = {
+  templateId: string;
+  name: string;
+  svg: string;
+  icon: string;
+};
+
+export type PlaceholderDefinition = {
+  name: string;
+  components: InsertOption[];
+  insertOptionsNode?: ItemDescriptor;
+};
+
+export type ComponentDetails = Component & {
+  compatibleRenderings: Rendering[];
+  template: Template;
+  placeholders: PlaceholderDefinition[];
+};
+
+export async function loadComponentDetails(
+  id: string,
+  contextItemId: string
+): Promise<ComponentDetails> {
+  let url =
+    "/alpaca/headless/component?id=" + id + "&contextItemId=" + contextItemId;
+
+  const response = await fetch(url, {
+    method: "GET",
+    credentials: "include",
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+
+  return await response.json();
+}
+
+export async function saveComponentDetails(
+  component: ComponentDetails,
+  contextItem: ItemDescriptor
+): Promise<boolean> {
+  let url = "/alpaca/headless/component/save";
+
+  const response = await post(url, {
+    component,
+    contextItem: getItemDescriptor(contextItem),
+  });
+
+  if (response.response.ok) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+export type Template = {
+  sections: TemplateSection[];
+};
+
+export type TemplateSection = {
+  id?: string;
+  name: string;
+  fields: TemplateField[];
+  key?: string;
+};
+
+export type TemplateField = {
+  id?: string;
+  name: string;
+  type: string;
+  source: string;
+  key?: string;
+};
+
+export type FieldTypeGroup = {
+  name: string;
+  types: string[];
+};

package/src/editor/services/contentService.ts

@@ -0,0 +1,180 @@
+import Cookies from "universal-cookie";
+
+import { get, post } from "./serviceHelper";
+import {
+  EditableDictionary,
+  LanguagesAndVersions,
+  Site,
+  WorkboxItem,
+  ContentEditorWarning,
+} from "../../types";
+import { FullItem, ItemDescriptor, ItemStub } from "../pageModel";
+
+export type ItemTreeNodeData = {
+  id: string;
+  name: string;
+  templateId: string;
+  icon: string;
+  hasChildren: boolean;
+  isComponent: boolean;
+  thumbUrl: string;
+  previewUrl: string;
+  resolution?: string;
+  format?: string;
+  created?: Date;
+  language: string;
+  version: number;
+  hasLayout: boolean;
+  path?: string;
+  idPath?: string;
+};
+
+export async function getChildren(
+  itemId: string,
+  sessionId: string,
+  templateIds: string[] = [],
+  includeEmbeddedItems: boolean,
+  language: string,
+  include?: string,
+): Promise<ItemTreeNodeData[]> {
+  let url =
+    // configuration.services.editorService.baseUrl +
+    "/alpaca/editor/children?itemId=" +
+    itemId +
+    "&sessionId=" +
+    sessionId +
+    "&includeEmbeddedItems=" +
+    includeEmbeddedItems +
+    "&language=" +
+    language +
+    "&include=" +
+    include;
+
+  url = templateIds.reduce((u, t) => u + "&templateIds=" + t, url);
+
+  const response = await fetch(url, {
+    method: "GET",
+    credentials: "include",
+    headers: {
+      "Content-Type": "application/json",
+      Cookie: new Cookies().getAll(),
+    },
+  });
+  return await response.json();
+}
+
+// export async function getItem(
+//   item: ItemDescriptor
+// ): Promise<FullItem | undefined> {
+//   let url =
+//     "/alpaca/editor/item?itemId=" +
+//     item.id +
+//     "&language=" +
+//     item.language +
+//     "&version=" +
+//     item.version;
+
+//   const response = await fetch(url, {
+//     method: "GET",
+
+//     credentials: "include",
+//     headers: {
+//       "Content-Type": "application/json",
+//       Cookie: new Cookies().getAll(),
+//     },
+//   });
+
+//   if (response.ok) {
+//     const json = await response.json();
+//     return json;
+//   }
+//   return undefined;
+// }
+
+export async function fetchItems(
+  itemDescriptors: ItemDescriptor[],
+): Promise<FullItem[] | undefined> {
+  let url = "/alpaca/editor/items";
+
+  const response = await post<FullItem[]>(url, itemDescriptors);
+  return response.data || [];
+}
+
+export async function fetchItemStubs(
+  itemDescriptors: ItemDescriptor[],
+): Promise<ItemStub[] | undefined> {
+  let url = "/alpaca/editor/itemstubs";
+
+  const response = await post<ItemStub[]>(url, itemDescriptors);
+  return response.data || [];
+}
+
+export async function getSites() {
+  return await get<Site[]>("/alpaca/editor/sites");
+}
+
+export async function resolvePageAndSite(
+  itemId: string,
+  language: string,
+  version: number,
+): Promise<
+  | { pageItem: ItemDescriptor; site: { name: string }; isHeadless: boolean }
+  | undefined
+> {
+  const result = await post<{
+    pageItem: ItemDescriptor;
+    site: { name: string };
+    isHeadless: boolean;
+  }>("/alpaca/editor/resolve", {
+    itemId,
+    language,
+    version,
+    mode: "edit",
+  });
+
+  if (result.data) {
+    return result.data;
+  }
+}
+
+export async function getLanguagesAndVersions(item: ItemDescriptor) {
+  return await post<LanguagesAndVersions>(
+    "/alpaca/editor/getLanguagesAndVersions",
+    item,
+  );
+}
+
+export async function getPageJson(page: ItemDescriptor) {
+  const response = await post("/alpaca/headless/layout", {
+    itemId: page.id,
+    language: page.language,
+    version: page.version,
+    mode: "preview",
+  });
+  return (response.data as any)?.page;
+}
+
+export async function getDictionary(siteName: string, language: string) {
+  let response = await get(
+    "/alpaca/editor/dictionary/index?siteName=" +
+      siteName +
+      "&language=" +
+      language,
+  );
+  return response.data as EditableDictionary;
+}
+
+export async function getWorkbox(items: ItemDescriptor[]) {
+  return await post<WorkboxItem[]>("/alpaca/editor/workbox", items);
+}
+
+export async function getContentEditorWarnings(item: ItemDescriptor) {
+  var data = await post<ContentEditorWarning[]>(
+    "/alpaca/editor/contentEditorWarnings",
+    item,
+  );
+  if (data.data) {
+    return data.data;
+  }
+  return [];
+}