@tulip-systems/core 0.4.1 → 0.5.1

package/src/modules/storage/lib/service.server.ts

@@ -0,0 +1,476 @@
+import { BUCKET_NAME } from "@/lib/config/constants";
+import { generateDefaultUUID, TDatabaseSchema } from "@/modules/config/entry";
+import { DatabaseClient } from "@/modules/config/entry.server";
+import {
+  convertOrderByToQueryParams,
+  convertSearchToQueryParams,
+} from "@/modules/data-tables/entry.server";
+import { BulkActionSchema } from "@/modules/router/entry";
+import { ServerError } from "@/modules/router/lib/error.server";
+import {
+  DeleteObjectsCommand,
+  GetObjectCommand,
+  PutObjectCommand,
+  S3Client,
+  S3ClientConfig,
+} from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { addSeconds } from "date-fns";
+import { and, asc, eq, inArray, isNull, SQL } from "drizzle-orm";
+import { after } from "next/server";
+import { deviceSizes } from "./constants";
+import { getDriveBucketKey, inferNodeSubtype, isFile, isFolder } from "./helpers";
+import { nodePresignedUrls, nodes, nodeVariants } from "./schema";
+import {
+  CreateFolderNodeSchema,
+  GetFileURLSchema,
+  getFileURLSchemaDefaults,
+  GetNodesByParentIdInput,
+  GetObjectInput,
+  getObjectSchema,
+  Node,
+  PresignFileSchema,
+  PutObjectInput,
+  putObjectSchema,
+  UpdateNodeSchema,
+  UploadFileSchema,
+} from "./validators";
+
+/**
+ * Storage Service Config
+ */
+export type StorageServiceConfig<TSchema extends TDatabaseSchema> = {
+  db: DatabaseClient<TSchema>;
+  config: S3ClientConfig;
+};
+
+/**
+ * Storage Service
+ */
+export class StorageService<TSchema extends TDatabaseSchema> {
+  /**
+   * S3 Client
+   */
+  #blob: S3Client;
+  #db: DatabaseClient<TSchema>;
+
+  /**
+   * Constructor
+   */
+  constructor({ db, config }: StorageServiceConfig<TSchema>) {
+    this.#db = db;
+    this.#blob = new S3Client(config);
+  }
+
+  /**
+   * Get Blob
+   */
+  blob() {
+    return this.#blob;
+  }
+
+  /**
+   * Create get command
+   */
+  #createGetCommand(props: GetObjectInput) {
+    const input = getObjectSchema.parse(props);
+
+    return new GetObjectCommand({
+      Bucket: BUCKET_NAME,
+      Key: getDriveBucketKey(input.id, input.variant),
+      ResponseContentDisposition: input.disposition,
+    });
+  }
+
+  /**
+   * Get object
+   */
+  async getObject(id: string, options: GetFileURLSchema = getFileURLSchemaDefaults) {
+    const getCommand = this.#createGetCommand({ ...options, id });
+
+    return await this.#blob.send(getCommand);
+  }
+
+  /**
+   * Create put command
+   */
+  #createPutCommand(props: PutObjectInput) {
+    const input = putObjectSchema.parse(props);
+
+    return new PutObjectCommand({
+      Bucket: BUCKET_NAME,
+      Key: getDriveBucketKey(input.id, input.variant),
+      Body: input.body,
+      ContentType: input.contentType,
+      ContentLength: input.size,
+      Metadata: {
+        nodeId: input.id,
+      },
+    });
+  }
+
+  /**
+   * Put object
+   */
+  async #putObject(props: PutObjectInput) {
+    const putCommand = this.#createPutCommand(props);
+    return await this.#blob.send(putCommand);
+  }
+
+  /**
+   * Get nodes by parent id
+   */
+  async getNodesByParentId({ filters, ...query }: GetNodesByParentIdInput) {
+    const orderBy = convertOrderByToQueryParams(query, nodes, asc(nodes.createdAt));
+    const search = convertSearchToQueryParams(query, [nodes.name]);
+
+    return this.#db
+      .select()
+      .from(nodes)
+      .where(
+        and(
+          filters.nodeIds != null ? inArray(nodes.id, filters.nodeIds) : undefined,
+          filters.types != null ? inArray(nodes.type, filters.types) : undefined,
+          filters.isDeleted != null ? eq(nodes.isDeleted, filters.isDeleted) : undefined,
+          filters.parentId ? eq(nodes.parentId, filters.parentId) : isNull(nodes.parentId),
+          eq(nodes.namespace, filters.namespace),
+          search,
+        ),
+      )
+      .orderBy(orderBy as SQL);
+  }
+
+  /**
+   * Get file url
+   */
+  async getSignedURL(node: Node, options: GetFileURLSchema = getFileURLSchemaDefaults) {
+    const [presignedUrl] = await this.#db
+      .select({ url: nodePresignedUrls.url, expiresAt: nodePresignedUrls.expiresAt })
+      .from(nodePresignedUrls)
+      .where(
+        and(
+          eq(nodePresignedUrls.nodeId, node.id),
+          eq(nodePresignedUrls.variant, options.variant),
+          eq(nodePresignedUrls.disposition, options.disposition),
+        ),
+      );
+
+    if (presignedUrl && presignedUrl.expiresAt > new Date()) return presignedUrl.url;
+
+    const expiresIn = 3600 * 24;
+
+    // Get the variants
+    const variants = await this.#db
+      .select()
+      .from(nodeVariants)
+      .where(eq(nodeVariants.nodeId, node.id));
+
+    // If the requested variant does not exist, fallback to main
+    const variantExists = variants.find((v) => v.variant === options.variant);
+    const variant = variantExists ? options.variant : "main";
+
+    console.info(
+      `Generating new signed url for file: ${node.id} with variant: ${variant} and disposition: ${options.disposition}`,
+    );
+
+    // Generate the get command
+    const getCommand = this.#createGetCommand({
+      id: node.id,
+      variant,
+      disposition: `${options.disposition}; filename="${node.name}"`,
+    });
+
+    // Generate the presigned url that expires in 24 hours
+    const url = await getSignedUrl(this.#blob, getCommand, { expiresIn });
+
+    // Add the presigned url to the database
+    after(async () => {
+      await this.#db
+        .insert(nodePresignedUrls)
+        .values({
+          nodeId: node.id,
+          url,
+          variant,
+          disposition: options.disposition,
+          expiresAt: addSeconds(new Date(), expiresIn),
+        })
+        .onConflictDoUpdate({
+          target: [
+            nodePresignedUrls.nodeId,
+            nodePresignedUrls.variant,
+            nodePresignedUrls.disposition,
+          ],
+          set: { url, expiresAt: addSeconds(new Date(), expiresIn) },
+        });
+    });
+
+    return url;
+  }
+
+  /**
+   * Upload file to S3 and add it to the database
+   **/
+  async uploadFile(input: UploadFileSchema & Pick<PutObjectInput, "body">) {
+    const id = generateDefaultUUID();
+
+    return await this.#db.transaction(async (tx) => {
+      const [result] = await tx
+        .insert(nodes)
+        .values({
+          id,
+          type: "file",
+          name: input.name,
+          namespace: input.namespace,
+          parentId: input.parentId,
+          size: input.size,
+          contentType: input.contentType,
+          mode: input.mode,
+          subtype: inferNodeSubtype(input),
+        })
+        .returning();
+
+      if (!result) {
+        throw new ServerError("INTERNAL_SERVER_ERROR", {
+          message: "Oep! Er is iets fout gegaan",
+        });
+      }
+
+      await this.#putObject({
+        id,
+        body: input.body,
+        variant: "main",
+        name: input.name,
+        contentType: input.contentType,
+        size: input.size,
+      });
+
+      return result;
+    });
+  }
+
+  /**
+   * Presign a new upload
+   */
+  async presignUpload(input: PresignFileSchema) {
+    // Generate the put command
+    const putCommand = this.#createPutCommand({
+      id: input.id,
+      name: input.name,
+      variant: "main",
+      contentType: input.contentType,
+      size: input.size,
+    });
+
+    // Generate the presigned url
+    const presignedUrl = await getSignedUrl(this.#blob, putCommand, { expiresIn: 3600 });
+
+    const [node] = await this.#db
+      .insert(nodes)
+      .values({
+        ...input,
+        subtype: inferNodeSubtype(input),
+        isPending: true,
+        type: "file",
+        id: input.id,
+      })
+      .returning();
+
+    if (!node) {
+      throw new ServerError("INTERNAL_SERVER_ERROR", {
+        message: "Oep! Er is iets fout gegaan",
+      });
+    }
+
+    // Return the result
+    return { id: input.id, presignedUrl, node };
+  }
+
+  /**
+   * Confirm a new upload
+   */
+  async confirmUpload(input: { id: string }) {
+    const [result] = await this.#db
+      .update(nodes)
+      .set({ isPending: false })
+      .where(eq(nodes.id, input.id))
+      .returning();
+
+    if (!result) {
+      throw new ServerError("NOT_FOUND", { message: "File not found" });
+    }
+
+    /**
+     * Generate the preview version of the file
+     */
+    // after(async () => {});
+    await this.generatePreviews(input);
+
+    return result;
+  }
+
+  /**
+   * Generate preview version of the file
+   */
+  async generatePreviews(input: { id: string }) {
+    /**
+     * Get the main version of the file
+     */
+    const getCommand = this.#createGetCommand({ id: input.id, variant: "main" });
+
+    const response = await this.#blob.send(getCommand);
+    const contentType = response.ContentType;
+    if (!response.Body) {
+      throw new ServerError("INTERNAL_SERVER_ERROR", {
+        message: "Oep! Er is iets fout gegaan",
+      });
+    }
+
+    /**
+     * Transform the main version of the file to a buffer
+     */
+    const byteArray = await response.Body.transformToByteArray();
+    const buffer = Buffer.from(byteArray);
+
+    /**
+     * Generate the preview versions for images
+     */
+    if (contentType?.startsWith("image/")) {
+      const sharp = await import("sharp");
+
+      // Generate the preview versions
+      await Promise.allSettled(
+        deviceSizes.flatMap(async (width) => {
+          // Generate the preview
+          const preview = await sharp.default(buffer).resize({ width }).webp().toBuffer();
+
+          // Upload the preview and add the variant to the database
+          return this.#db.transaction(async (tx) => {
+            await this.#putObject({
+              id: input.id,
+              body: preview,
+              variant: `preview-${width}`,
+              contentType: "image/webp",
+              size: preview.byteLength,
+            });
+
+            await tx.insert(nodeVariants).values({
+              nodeId: input.id,
+              variant: `preview-${width}`,
+              width,
+            });
+          });
+        }),
+      );
+    }
+  }
+
+  /**
+   * Create a new folder
+   */
+  async createFolder(input: CreateFolderNodeSchema) {
+    const [parent] = input.parentId
+      ? await this.#db.select().from(nodes).where(eq(nodes.id, input.parentId))
+      : [];
+
+    /**
+     * Validate
+     */
+    if (input.parentId && !parent) {
+      throw new ServerError("BAD_REQUEST", { message: "Parent not found" });
+    }
+
+    if (parent && !isFolder(parent)) {
+      throw new ServerError("BAD_REQUEST", { message: "Parent is not a folder" });
+    }
+
+    if (parent && parent.namespace !== input.namespace) {
+      throw new ServerError("BAD_REQUEST", {
+        message: "Parent is not in the same namespace",
+      });
+    }
+
+    /**
+     * Create the folder
+     */
+    const [result] = await this.#db
+      .insert(nodes)
+      .values({ ...input, type: "folder" })
+      .returning();
+
+    if (!result) {
+      throw new ServerError("INTERNAL_SERVER_ERROR", {
+        message: "Folder kon niet worden aangemaakt",
+      });
+    }
+
+    return result;
+  }
+
+  /**
+   * Update a node
+   */
+  async updateNode(input: { id: string; data: UpdateNodeSchema }) {
+    const [node] = await this.#db
+      .select({ readonly: nodes.readonly })
+      .from(nodes)
+      .where(eq(nodes.id, input.id));
+
+    if (node?.readonly) {
+      throw new ServerError("BAD_REQUEST", { message: "Node is readonly" });
+    }
+
+    const [result] = await this.#db
+      .update(nodes)
+      .set(input.data)
+      .where(eq(nodes.id, input.id))
+      .returning();
+
+    if (!result) {
+      throw new ServerError("INTERNAL_SERVER_ERROR", {
+        message: "Node kon niet worden gewijzigd",
+      });
+    }
+
+    return result;
+  }
+
+  /**
+   * Delete nodes
+   */
+  async deleteNodes(input: BulkActionSchema) {
+    const items = await this.#db
+      .select({ id: nodes.id, type: nodes.type, readonly: nodes.readonly })
+      .from(nodes)
+      .where(inArray(nodes.id, input.ids));
+
+    // Check if the nodes are readonly
+    if (items.some((item) => item.readonly)) {
+      throw new ServerError("BAD_REQUEST", { message: "Nodes are readonly" });
+    }
+
+    // Split the nodes into folders and files
+    const folders = items.filter(isFolder).map((folder) => folder.id);
+    const files = items.filter(isFile).map((file) => file.id);
+
+    // Delete command for S3
+    const deleteCommand =
+      files.length > 0
+        ? new DeleteObjectsCommand({
+            Bucket: BUCKET_NAME,
+            Delete: {
+              Objects: files.map((id) => ({ Key: id })),
+            },
+          })
+        : undefined;
+
+    /**
+     * Delete files and folders in a transaction
+     */
+    await this.#db.transaction(async (tx) => {
+      await tx.delete(nodes).where(inArray(nodes.id, folders));
+      await tx.delete(nodes).where(inArray(nodes.id, files));
+
+      if (deleteCommand) await this.#blob.send(deleteCommand);
+    });
+  }
+}

package/src/modules/storage/lib/validators.ts

@@ -0,0 +1,156 @@
+import { tableQuerySchema } from "@/modules/data-tables/entry";
+import { resolveFiltersSchema } from "@/modules/data-tables/lib/filters/resolvers";
+import { PutObjectCommandInput } from "@aws-sdk/client-s3";
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from "drizzle-zod";
+import { z } from "zod";
+import { nodesTableFilters } from "../config/filters";
+import { imageDispositions, imageVariants } from "./constants";
+import { nodeModeEnum, nodes } from "./schema";
+
+/**
+ * Nodes
+ */
+export type Node = typeof nodes.$inferSelect;
+export type FileNode = typeof nodes.$inferSelect & { type: "file" };
+export type FolderNode = typeof nodes.$inferSelect & { type: "folder" };
+
+/**
+ * Node mode
+ */
+export const nodeModeSchema = z.enum(nodeModeEnum.enumValues);
+export type NodeMode = z.infer<typeof nodeModeSchema>;
+
+/**
+ * Create node
+ */
+export const createNodeSchema = createInsertSchema(nodes, {
+  namespace: z.string(),
+});
+
+export type CreateNodeInput = z.input<typeof createNodeSchema>;
+export type CreateNodeSchema = z.infer<typeof createNodeSchema>;
+
+/**
+ * Update node
+ */
+export const updateNodeSchema = createUpdateSchema(nodes);
+
+export type UpdateNodeInput = z.input<typeof updateNodeSchema>;
+export type UpdateNodeSchema = z.infer<typeof updateNodeSchema>;
+
+/**
+ * Create folder node
+ */
+export const createFolderNodeSchema = createNodeSchema.omit({
+  type: true,
+  contentType: true,
+  size: true,
+  subtype: true,
+});
+
+export type CreateFolderNodeSchema = z.infer<typeof createFolderNodeSchema>;
+
+/**
+ * Create file node
+ */
+export const createFileNodeSchema = createNodeSchema.omit({
+  type: true,
+});
+export type CreateFileNodeSchema = z.infer<typeof createFileNodeSchema>;
+
+/**
+ * Select node
+ */
+export const selectNodeSchema = createSelectSchema(nodes);
+export const selectNodeWithChildrenSchema = selectNodeSchema.extend({
+  children: z.array(selectNodeSchema),
+});
+
+export type SelectNodeSchema = z.infer<typeof selectNodeSchema>;
+export type SelectNodeWithChildrenSchema = z.infer<typeof selectNodeWithChildrenSchema>;
+
+/**
+ * Where input
+ */
+export const nodesTableFiltersSchema = resolveFiltersSchema(nodesTableFilters)
+  .partial()
+  .extend({
+    namespace: z.string(),
+    parentId: z.string().nullable(),
+  })
+  .transform((input) => ({ ...input, isDeleted: input?.isDeleted ?? false }));
+
+export type NodesTableFilters = z.input<typeof nodesTableFiltersSchema>;
+
+/**
+ * Upload file schema
+ */
+export const uploadFileSchema = z.object({
+  name: z.string().min(1),
+  namespace: z.string(),
+  mode: nodeModeSchema.optional(),
+  parentId: z.uuid().nullable(),
+  size: z.number().optional().default(0),
+  contentType: z.string().optional().default(""),
+});
+
+export type UploadFileSchema = z.infer<typeof uploadFileSchema>;
+
+/**
+ * Presign file schema
+ */
+export const presignFileSchema = uploadFileSchema.extend({ id: z.uuid() });
+
+export type PresignFileSchema = z.infer<typeof presignFileSchema>;
+
+/**
+ * Get file url schema
+ */
+export const getFileURLSchemaDefaults = { variant: "main", disposition: "inline" } as const;
+
+export const getFileURLSchema = z.object({
+  variant: z.enum(imageVariants).optional().default(getFileURLSchemaDefaults.variant),
+  disposition: z.enum(imageDispositions).optional().default(getFileURLSchemaDefaults.disposition),
+});
+
+export type GetFileUrlInput = z.input<typeof getFileURLSchema>;
+export type GetFileURLSchema = z.infer<typeof getFileURLSchema>;
+
+/**
+ * Get by parent id input
+ */
+export const getNodesByParentIdSchema = tableQuerySchema
+  .pick({ order: true, sort: true, search: true })
+  .extend({ filters: nodesTableFiltersSchema });
+
+export type GetNodesByParentIdInput = z.input<typeof getNodesByParentIdSchema>;
+
+/**
+ * Get object input
+ */
+export const getObjectSchema = z.object({
+  id: z.string(),
+  variant: z.enum(imageVariants).optional().default(getFileURLSchemaDefaults.variant),
+  disposition: z.string().optional().default(getFileURLSchemaDefaults.disposition),
+});
+
+export type GetObjectInput = z.input<typeof getObjectSchema>;
+export type GetObjectSchema = z.infer<typeof getObjectSchema>;
+
+/**
+ * Put object input
+ */
+export const putObjectSchema = z.object({
+  id: z.string(),
+  name: z.string().optional().default(""),
+  variant: z.enum(imageVariants).optional().default("main"),
+  body: z.any().optional(),
+  contentType: z.string().optional().default(""),
+  size: z.number().optional().default(0),
+});
+
+export type PutObjectInput = z.input<typeof putObjectSchema> & {
+  body?: PutObjectCommandInput["Body"];
+};
+
+export type PutObjectSchema = z.infer<typeof putObjectSchema>;

package/dist/components/editor/components/block-dropdown.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"block-dropdown.mjs","names":["Icon"],"sources":["../../../../src/components/editor/components/block-dropdown.tsx"],"sourcesContent":["import { Button } from \"@/components/ui/button\";\nimport {\n  DropdownMenu,\n  DropdownMenuContent,\n  DropdownMenuItem,\n  DropdownMenuTrigger,\n} from \"@/components/ui/dropdown-menu\";\nimport { Editor } from \"@tiptap/react\";\nimport {\n  ChevronDown,\n  Heading1Icon,\n  Heading2Icon,\n  Heading3Icon,\n  Heading4Icon,\n  Heading5Icon,\n  ListIcon,\n  ListOrderedIcon,\n  TextIcon,\n} from \"lucide-react\";\nimport { useContext } from \"react\";\nimport { EditorContext } from \"../context.client\";\n\nconst blocks = [\n  {\n    label: \"Paragraaf\",\n    icon: TextIcon,\n    selected: (editor: Editor) => editor.isActive(\"paragraph\"),\n    handler: (editor: Editor) => editor.commands.setParagraph(),\n  },\n  {\n    label: \"Titel 1\",\n    icon: Heading1Icon,\n    selected: (editor: Editor) => editor.isActive(\"heading\", { level: 1 }),\n    handler: (editor: Editor) => editor.commands.setHeading({ level: 1 }),\n  },\n  {\n    label: \"Titel 2\",\n    icon: Heading2Icon,\n    selected: (editor: Editor) => editor.isActive(\"heading\", { level: 2 }),\n    handler: (editor: Editor) => editor.commands.setHeading({ level: 2 }),\n  },\n  {\n    label: \"Titel 3\",\n    icon: Heading3Icon,\n    selected: (editor: Editor) => editor.isActive(\"heading\", { level: 3 }),\n    handler: (editor: Editor) => editor.commands.setHeading({ level: 3 }),\n  },\n  {\n    label: \"Titel 4\",\n    icon: Heading4Icon,\n    selected: (editor: Editor) => editor.isActive(\"heading\", { level: 4 }),\n    handler: (editor: Editor) => editor.commands.setHeading({ level: 4 }),\n  },\n  {\n    label: \"Titel 5\",\n    icon: Heading5Icon,\n    selected: (editor: Editor) => editor.isActive(\"heading\", { level: 5 }),\n    handler: (editor: Editor) => editor.commands.setHeading({ level: 5 }),\n  },\n  {\n    label: \"Numbered List\",\n    icon: ListOrderedIcon,\n    selected: (editor: Editor) => editor.isActive(\"orderedList\"),\n    handler: (editor: Editor) => editor.commands.toggleOrderedList(),\n  },\n  {\n    label: \"Bulleted List\",\n    icon: ListIcon,\n    selected: (editor: Editor) => editor.isActive(\"bulletList\"),\n    handler: (editor: Editor) => editor.commands.toggleBulletList(),\n  },\n];\n\nexport function BlockDropdown() {\n  const { editor } = useContext(EditorContext);\n\n  const selectedBlock = blocks.find((block) => block.selected(editor));\n  const Icon = selectedBlock?.icon;\n\n  return (\n    <DropdownMenu>\n      <DropdownMenuTrigger asChild>\n        <Button variant=\"outline\" size=\"sm\" className=\"flex items-center gap-8 p-2\">\n          <span className=\"flex items-center gap-2\">\n            {Icon && <Icon className=\"size-3.5\" />}\n            {selectedBlock?.label ?? \"Select a block\"}\n          </span>\n\n          <ChevronDown className=\"size-3.5\" />\n        </Button>\n      </DropdownMenuTrigger>\n\n      <DropdownMenuContent>\n        {blocks.map(({ label, icon: Icon, handler }, index) => (\n          <DropdownMenuItem\n            key={index}\n            onClick={() => handler(editor)}\n            className=\"flex items-center gap-2\"\n          >\n            {Icon && <Icon className=\"size-3.5\" />}\n            {label}\n          </DropdownMenuItem>\n        ))}\n      </DropdownMenuContent>\n    </DropdownMenu>\n  );\n}\n"],"mappings":";;;;;;;;AAsBA,MAAM,SAAS;CACb;EACE,OAAO;EACP,MAAM;EACN,WAAW,WAAmB,OAAO,SAAS,YAAY;EAC1D,UAAU,WAAmB,OAAO,SAAS,cAAc;EAC5D;CACD;EACE,OAAO;EACP,MAAM;EACN,WAAW,WAAmB,OAAO,SAAS,WAAW,EAAE,OAAO,GAAG,CAAC;EACtE,UAAU,WAAmB,OAAO,SAAS,WAAW,EAAE,OAAO,GAAG,CAAC;EACtE;CACD;EACE,OAAO;EACP,MAAM;EACN,WAAW,WAAmB,OAAO,SAAS,WAAW,EAAE,OAAO,GAAG,CAAC;EACtE,UAAU,WAAmB,OAAO,SAAS,WAAW,EAAE,OAAO,GAAG,CAAC;EACtE;CACD;EACE,OAAO;EACP,MAAM;EACN,WAAW,WAAmB,OAAO,SAAS,WAAW,EAAE,OAAO,GAAG,CAAC;EACtE,UAAU,WAAmB,OAAO,SAAS,WAAW,EAAE,OAAO,GAAG,CAAC;EACtE;CACD;EACE,OAAO;EACP,MAAM;EACN,WAAW,WAAmB,OAAO,SAAS,WAAW,EAAE,OAAO,GAAG,CAAC;EACtE,UAAU,WAAmB,OAAO,SAAS,WAAW,EAAE,OAAO,GAAG,CAAC;EACtE;CACD;EACE,OAAO;EACP,MAAM;EACN,WAAW,WAAmB,OAAO,SAAS,WAAW,EAAE,OAAO,GAAG,CAAC;EACtE,UAAU,WAAmB,OAAO,SAAS,WAAW,EAAE,OAAO,GAAG,CAAC;EACtE;CACD;EACE,OAAO;EACP,MAAM;EACN,WAAW,WAAmB,OAAO,SAAS,cAAc;EAC5D,UAAU,WAAmB,OAAO,SAAS,mBAAmB;EACjE;CACD;EACE,OAAO;EACP,MAAM;EACN,WAAW,WAAmB,OAAO,SAAS,aAAa;EAC3D,UAAU,WAAmB,OAAO,SAAS,kBAAkB;EAChE;CACF;AAED,SAAgB,gBAAgB;CAC9B,MAAM,EAAE,WAAW,WAAW,cAAc;CAE5C,MAAM,gBAAgB,OAAO,MAAM,UAAU,MAAM,SAAS,OAAO,CAAC;CACpE,MAAM,OAAO,eAAe;AAE5B,QACE,qBAAC,2BACC,oBAAC;EAAoB;YACnB,qBAAC;GAAO,SAAQ;GAAU,MAAK;GAAK,WAAU;cAC5C,qBAAC;IAAK,WAAU;eACb,QAAQ,oBAAC,QAAK,WAAU,aAAa,EACrC,eAAe,SAAS;KACpB,EAEP,oBAAC,eAAY,WAAU,aAAa;IAC7B;GACW,EAEtB,oBAAC,iCACE,OAAO,KAAK,EAAE,OAAO,MAAMA,QAAM,WAAW,UAC3C,qBAAC;EAEC,eAAe,QAAQ,OAAO;EAC9B,WAAU;aAETA,UAAQ,oBAACA,UAAK,WAAU,aAAa,EACrC;IALI,MAMY,CACnB,GACkB,IACT"}

package/dist/components/editor/components/fixed-menu.client.d.mts

@@ -1,7 +0,0 @@
-import * as react_jsx_runtime122 from "react/jsx-runtime";
-
-//#region src/components/editor/components/fixed-menu.client.d.ts
-declare function FixedMenu(): react_jsx_runtime122.JSX.Element;
-//#endregion
-export { FixedMenu };
-//# sourceMappingURL=fixed-menu.client.d.mts.map

package/dist/components/editor/components/fixed-menu.client.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fixed-menu.client.d.mts","names":[],"sources":["../../../../src/components/editor/components/fixed-menu.client.tsx"],"sourcesContent":[],"mappings":";;;iBAmBgB,SAAA,CAAA,GAAS,oBAAA,CAAA,GAAA,CAAA"}