@withwiz/gallery 0.1.0

package/dist/server/index.js

@@ -0,0 +1,619 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+var _chunkGFOWZGJXjs = require('../chunk-GFOWZGJX.js');
+
+
+
+var _chunkWVRTM6E7js = require('../chunk-WVRTM6E7.js');
+
+
+var _chunkILSZPLMEjs = require('../chunk-ILSZPLME.js');
+
+// src/services/helpers.ts
+function buildPaginatedResult(items, page, limit, total) {
+  const totalPages = total === 0 ? 0 : Math.ceil(total / limit);
+  return {
+    items,
+    meta: {
+      page,
+      limit,
+      total,
+      totalPages,
+      hasNext: page < totalPages,
+      hasPrev: page > 1
+    }
+  };
+}
+
+// src/services/category-service.ts
+function createCategoryService(config) {
+  const categoryDelegate = () => config.prisma[_nullishCoalesce(config.categoryModelName, () => ( "galleryCategory"))];
+  const galleryDelegate = () => config.prisma[_nullishCoalesce(config.modelName, () => ( "gallery"))];
+  async function list(opts) {
+    const where = _optionalChain([opts, 'optionalAccess', _ => _.isActive]) !== void 0 ? { isActive: opts.isActive } : void 0;
+    const rows = await categoryDelegate().findMany({
+      ...where ? { where } : {},
+      orderBy: [{ sortOrder: "asc" }, { createdAt: "asc" }]
+    });
+    return rows;
+  }
+  async function getBySlug(slug) {
+    const row = await categoryDelegate().findUnique({ where: { slug } });
+    return _nullishCoalesce(row, () => ( null));
+  }
+  async function getById(id) {
+    const row = await categoryDelegate().findUnique({ where: { id } });
+    return _nullishCoalesce(row, () => ( null));
+  }
+  async function create(data) {
+    const row = await categoryDelegate().create({ data });
+    return row;
+  }
+  async function update(id, data) {
+    const row = await categoryDelegate().update({ where: { id }, data });
+    return row;
+  }
+  async function remove(id) {
+    const inUse = await galleryDelegate().count({ where: { categoryId: id } });
+    if (inUse > 0) {
+      throw new (0, _chunkGFOWZGJXjs.CategoryInUseError)(id, inUse);
+    }
+    await categoryDelegate().delete({ where: { id } });
+  }
+  async function reorder(ids) {
+    const ops = ids.map(
+      (id, idx) => categoryDelegate().update({ where: { id }, data: { sortOrder: idx } })
+    );
+    await config.prisma.$transaction(ops);
+  }
+  return { list, getBySlug, getById, create, update, remove, reorder };
+}
+
+// src/services/index.ts
+function createGalleryService(config) {
+  const galleryDelegate = () => config.prisma[_nullishCoalesce(config.modelName, () => ( "gallery"))];
+  const baseInclude = { category: true };
+  function orderByFor(sortBy) {
+    switch (sortBy) {
+      case "sortOrder":
+        return [{ sortOrder: "asc" }, { createdAt: "desc" }];
+      case "caption":
+        return { caption: "asc" };
+      case "createdAt":
+      case "updatedAt":
+        return { [sortBy]: "desc" };
+    }
+  }
+  async function listFeatured(limit) {
+    const rows = await galleryDelegate().findMany({
+      where: { published: true, featured: true },
+      include: baseInclude,
+      orderBy: [{ sortOrder: "asc" }, { createdAt: "desc" }],
+      ...limit ? { take: limit } : {}
+    });
+    return rows;
+  }
+  async function listPublished(limit) {
+    const rows = await galleryDelegate().findMany({
+      where: { published: true },
+      include: baseInclude,
+      orderBy: [{ sortOrder: "asc" }, { createdAt: "desc" }],
+      ...limit ? { take: limit } : {}
+    });
+    return rows;
+  }
+  async function listPublishedByCategory(categorySlug, limit) {
+    const rows = await galleryDelegate().findMany({
+      where: { published: true, category: { slug: categorySlug } },
+      include: baseInclude,
+      orderBy: [{ sortOrder: "asc" }, { createdAt: "desc" }],
+      ...limit ? { take: limit } : {}
+    });
+    return rows;
+  }
+  async function listAll(opts) {
+    const page = _nullishCoalesce(opts.page, () => ( 1));
+    const limit = _nullishCoalesce(opts.limit, () => ( 20));
+    const sortBy = _nullishCoalesce(opts.sortBy, () => ( "sortOrder"));
+    const skip = (page - 1) * limit;
+    const where = {};
+    if (opts.categoryId) where.categoryId = opts.categoryId;
+    if (opts.published !== void 0) where.published = opts.published;
+    if (opts.search) where.caption = { contains: opts.search, mode: "insensitive" };
+    const [items, total] = await Promise.all([
+      galleryDelegate().findMany({
+        where,
+        include: baseInclude,
+        orderBy: orderByFor(sortBy),
+        skip,
+        take: limit
+      }),
+      galleryDelegate().count({ where })
+    ]);
+    return buildPaginatedResult(items, page, limit, total);
+  }
+  async function getById(id) {
+    const row = await galleryDelegate().findUnique({
+      where: { id },
+      include: baseInclude
+    });
+    return _nullishCoalesce(row, () => ( null));
+  }
+  async function create(data, authorId) {
+    const row = await galleryDelegate().create({
+      data: {
+        imageUrl: data.imageUrl,
+        imageKey: _nullishCoalesce(data.imageKey, () => ( null)),
+        caption: _nullishCoalesce(data.caption, () => ( null)),
+        categoryId: data.categoryId,
+        sortOrder: _nullishCoalesce(data.sortOrder, () => ( 0)),
+        featured: _nullishCoalesce(data.featured, () => ( false)),
+        published: _nullishCoalesce(data.published, () => ( false)),
+        authorId
+      },
+      include: baseInclude
+    });
+    return row;
+  }
+  async function createMany(items, authorId) {
+    const result = await galleryDelegate().createMany({
+      data: items.map((it) => ({
+        imageUrl: it.imageUrl,
+        imageKey: _nullishCoalesce(it.imageKey, () => ( null)),
+        caption: _nullishCoalesce(it.caption, () => ( null)),
+        categoryId: it.categoryId,
+        sortOrder: _nullishCoalesce(it.sortOrder, () => ( 0)),
+        featured: _nullishCoalesce(it.featured, () => ( false)),
+        published: _nullishCoalesce(it.published, () => ( false)),
+        authorId
+      }))
+    });
+    return { count: result.count };
+  }
+  async function update(id, data) {
+    const patch = {};
+    if (data.imageUrl !== void 0) patch.imageUrl = data.imageUrl;
+    if (data.imageKey !== void 0) patch.imageKey = _nullishCoalesce(data.imageKey, () => ( null));
+    if (data.caption !== void 0) patch.caption = _nullishCoalesce(data.caption, () => ( null));
+    if (data.categoryId !== void 0) patch.categoryId = data.categoryId;
+    if (data.sortOrder !== void 0) patch.sortOrder = data.sortOrder;
+    if (data.featured !== void 0) patch.featured = data.featured;
+    if (data.published !== void 0) patch.published = data.published;
+    const row = await galleryDelegate().update({
+      where: { id },
+      data: patch,
+      include: baseInclude
+    });
+    return row;
+  }
+  async function remove(id) {
+    const storageEnabled = _optionalChain([config, 'access', _2 => _2.storage, 'optionalAccess', _3 => _3.isEnabled, 'optionalCall', _4 => _4()]) === true;
+    let imageKey = null;
+    if (storageEnabled) {
+      const row = await galleryDelegate().findUnique({
+        where: { id },
+        select: { imageKey: true }
+      });
+      imageKey = _nullishCoalesce(_optionalChain([row, 'optionalAccess', _5 => _5.imageKey]), () => ( null));
+    }
+    await galleryDelegate().delete({ where: { id } });
+    if (storageEnabled && imageKey && config.storage) {
+      const keys = config.storage.collectKeys(imageKey);
+      if (keys.length > 0) await config.storage.deleteKeys(keys);
+    }
+  }
+  async function removeMany(ids) {
+    const storageEnabled = _optionalChain([config, 'access', _6 => _6.storage, 'optionalAccess', _7 => _7.isEnabled, 'optionalCall', _8 => _8()]) === true;
+    let imageKeys = [];
+    if (storageEnabled) {
+      const rows = await galleryDelegate().findMany({
+        where: { id: { in: ids } },
+        select: { imageKey: true }
+      });
+      imageKeys = rows.map((r) => r.imageKey).filter((k) => typeof k === "string" && k.length > 0);
+    }
+    const result = await galleryDelegate().deleteMany({ where: { id: { in: ids } } });
+    if (storageEnabled && imageKeys.length > 0 && config.storage) {
+      const allKeys = imageKeys.flatMap((k) => config.storage.collectKeys(k));
+      const uniqueKeys = [...new Set(allKeys)];
+      if (uniqueKeys.length > 0) await config.storage.deleteKeys(uniqueKeys);
+    }
+    return { count: result.count };
+  }
+  async function bulkUpdatePublished(ids, published) {
+    const result = await galleryDelegate().updateMany({
+      where: { id: { in: ids } },
+      data: { published, updatedAt: /* @__PURE__ */ new Date() }
+    });
+    return { count: result.count };
+  }
+  async function bulkUpdateFeatured(ids, featured) {
+    const result = await galleryDelegate().updateMany({
+      where: { id: { in: ids } },
+      data: { featured, updatedAt: /* @__PURE__ */ new Date() }
+    });
+    return { count: result.count };
+  }
+  async function togglePublish(id) {
+    const current = await galleryDelegate().findUnique({
+      where: { id },
+      select: { published: true }
+    });
+    if (!current) {
+      throw new (0, _chunkGFOWZGJXjs.GalleryNotFoundError)(id);
+    }
+    const row = await galleryDelegate().update({
+      where: { id },
+      data: { published: !current.published },
+      include: baseInclude
+    });
+    return row;
+  }
+  async function count(opts) {
+    const where = _optionalChain([opts, 'optionalAccess', _9 => _9.published]) !== void 0 ? { published: opts.published } : void 0;
+    const n = await galleryDelegate().count(where ? { where } : {});
+    return n;
+  }
+  async function listRecent(limit) {
+    const rows = await galleryDelegate().findMany({
+      include: baseInclude,
+      orderBy: { createdAt: "desc" },
+      take: limit
+    });
+    return rows;
+  }
+  return {
+    listFeatured,
+    listPublished,
+    listPublishedByCategory,
+    listAll,
+    getById,
+    create,
+    createMany,
+    update,
+    remove,
+    removeMany,
+    bulkUpdatePublished,
+    bulkUpdateFeatured,
+    togglePublish,
+    count,
+    listRecent
+  };
+}
+
+// src/server/route-handlers.ts
+var _server = require('next/server');
+
+// src/utils/api-helpers.ts
+
+function parsePagination(req) {
+  const { searchParams } = new URL(req.url);
+  const rawPage = Number.parseInt(_nullishCoalesce(searchParams.get("page"), () => ( "1")), 10);
+  const rawLimit = Number.parseInt(_nullishCoalesce(searchParams.get("limit"), () => ( "20")), 10);
+  const page = Number.isFinite(rawPage) && rawPage > 0 ? rawPage : 1;
+  const limit = Number.isFinite(rawLimit) && rawLimit > 0 ? Math.min(rawLimit, 100) : 20;
+  return { page, limit };
+}
+function getSearchParam(req, key) {
+  const { searchParams } = new URL(req.url);
+  const v = searchParams.get(key);
+  return _nullishCoalesce(v, () => ( void 0));
+}
+function validateAndParse(schema, data) {
+  const parsed = schema.safeParse(data);
+  if (parsed.success) return { success: true, data: parsed.data };
+  return {
+    success: false,
+    response: _server.NextResponse.json(
+      { success: false, error: "ValidationError", details: parsed.error.issues },
+      { status: 400 }
+    )
+  };
+}
+function validateIds(input) {
+  if (!Array.isArray(input) || input.length === 0) {
+    return {
+      valid: false,
+      response: _server.NextResponse.json(
+        { success: false, error: "InvalidIds", message: "ids must be a non-empty array" },
+        { status: 400 }
+      )
+    };
+  }
+  const ids = input.filter((x) => typeof x === "string" && x.length > 0);
+  if (ids.length === 0) {
+    return {
+      valid: false,
+      response: _server.NextResponse.json(
+        { success: false, error: "InvalidIds", message: "ids array contains no valid strings" },
+        { status: 400 }
+      )
+    };
+  }
+  return { valid: true, ids };
+}
+function parseSortKey(searchParams, allowed, fallback) {
+  const raw = searchParams.get("sortBy");
+  return raw && allowed.includes(raw) ? raw : fallback;
+}
+
+// src/server/route-handlers.ts
+var VALID_SORT_KEYS = [
+  "sortOrder",
+  "createdAt",
+  "updatedAt",
+  "caption"
+];
+function jsonError(message, status, error) {
+  return _server.NextResponse.json(
+    { success: false, error: _nullishCoalesce(error, () => ( "Error")), message },
+    { status }
+  );
+}
+function callRevalidate(config) {
+  if (!config.revalidate || !config.revalidatePaths) return;
+  for (const p of config.revalidatePaths) {
+    config.revalidate(p);
+  }
+}
+function getAuthorId(config, ctx) {
+  if (config.authorIdFromContext) {
+    try {
+      const id = config.authorIdFromContext(ctx);
+      return id || null;
+    } catch (e) {
+      return null;
+    }
+  }
+  return _nullishCoalesce(_optionalChain([ctx, 'access', _10 => _10.user, 'optionalAccess', _11 => _11.id]), () => ( null));
+}
+function getRouteId(ctx) {
+  const id = _optionalChain([ctx, 'access', _12 => _12.params, 'optionalAccess', _13 => _13.id]);
+  return typeof id === "string" && id.length > 0 ? id : null;
+}
+function createGalleryRoutes(config) {
+  const service = createGalleryService(config);
+  const categoryService = createCategoryService(config);
+  const schemas = _chunkILSZPLMEjs.createGallerySchemas.call(void 0, {
+    batchMax: config.limits.batchMax,
+    captionMaxLength: _nullishCoalesce(config.limits.captionMaxLength, () => ( 200))
+  });
+  const collectionGET = config.apiWrapper(async (ctx) => {
+    const { page, limit } = parsePagination(ctx.request);
+    const { searchParams } = new URL(ctx.request.url);
+    const categoryId = getSearchParam(ctx.request, "categoryId");
+    const publishedRaw = getSearchParam(ctx.request, "published");
+    const search = getSearchParam(ctx.request, "search");
+    const sortBy = parseSortKey(
+      searchParams,
+      VALID_SORT_KEYS,
+      "sortOrder"
+    );
+    const published = publishedRaw === "true" ? true : publishedRaw === "false" ? false : void 0;
+    const result = await service.listAll({
+      page,
+      limit,
+      categoryId,
+      published,
+      search,
+      sortBy
+    });
+    return _server.NextResponse.json({ success: true, data: result });
+  });
+  const collectionPOST = config.apiWrapper(async (ctx) => {
+    const authorId = getAuthorId(config, ctx);
+    if (!authorId) return jsonError("authentication required", 401, "Unauthorized");
+    const body = await ctx.request.json();
+    const validation = validateAndParse(schemas.CreateGallerySchema, body);
+    if (!validation.success) return validation.response;
+    const item = await service.create(validation.data, authorId);
+    callRevalidate(config);
+    return _server.NextResponse.json({ success: true, data: item }, { status: 201 });
+  });
+  const collectionDELETE = config.apiWrapper(async (ctx) => {
+    const body = await ctx.request.json();
+    const check = validateIds(_optionalChain([body, 'optionalAccess', _14 => _14.ids]));
+    if (!check.valid) return check.response;
+    const { count } = await service.removeMany(check.ids);
+    callRevalidate(config);
+    return _server.NextResponse.json({ success: true, data: { count } });
+  });
+  const itemGET = config.apiWrapper(async (ctx) => {
+    const id = getRouteId(ctx);
+    if (!id) return jsonError("missing route param: id", 400, "InvalidParams");
+    const item = await service.getById(id);
+    if (!item) return jsonError("Gallery item not found", 404, "NotFound");
+    return _server.NextResponse.json({ success: true, data: item });
+  });
+  const itemPUT = config.apiWrapper(async (ctx) => {
+    const id = getRouteId(ctx);
+    if (!id) return jsonError("missing route param: id", 400, "InvalidParams");
+    const body = await ctx.request.json();
+    const validation = validateAndParse(schemas.UpdateGallerySchema, body);
+    if (!validation.success) return validation.response;
+    const existing = await service.getById(id);
+    if (!existing) return jsonError("Gallery item not found", 404, "NotFound");
+    if (_optionalChain([config, 'access', _15 => _15.permissions, 'optionalAccess', _16 => _16.canEdit])) {
+      const ok = config.permissions.canEdit(ctx, { authorId: existing.authorId });
+      if (!ok) return jsonError("forbidden", 403, "Forbidden");
+    }
+    const item = await service.update(id, validation.data);
+    callRevalidate(config);
+    return _server.NextResponse.json({ success: true, data: item });
+  });
+  const itemDELETE = config.apiWrapper(async (ctx) => {
+    const id = getRouteId(ctx);
+    if (!id) return jsonError("missing route param: id", 400, "InvalidParams");
+    if (_optionalChain([config, 'access', _17 => _17.permissions, 'optionalAccess', _18 => _18.canDelete])) {
+      const existing = await service.getById(id);
+      if (!existing) return jsonError("Gallery item not found", 404, "NotFound");
+      const ok = config.permissions.canDelete(ctx, {
+        authorId: existing.authorId
+      });
+      if (!ok) return jsonError("forbidden", 403, "Forbidden");
+    }
+    await service.remove(id);
+    callRevalidate(config);
+    return new (0, _server.NextResponse)(null, { status: 204 });
+  });
+  const publishTogglePATCH = config.apiWrapper(async (ctx) => {
+    const id = getRouteId(ctx);
+    if (!id) return jsonError("missing route param: id", 400, "InvalidParams");
+    if (_optionalChain([config, 'access', _19 => _19.permissions, 'optionalAccess', _20 => _20.canEdit])) {
+      const existing = await service.getById(id);
+      if (!existing) return jsonError("Gallery item not found", 404, "NotFound");
+      const ok = config.permissions.canEdit(ctx, {
+        authorId: existing.authorId
+      });
+      if (!ok) return jsonError("forbidden", 403, "Forbidden");
+    }
+    try {
+      const result = await service.togglePublish(id);
+      callRevalidate(config);
+      return _server.NextResponse.json({ success: true, data: result });
+    } catch (err) {
+      if (err instanceof _chunkGFOWZGJXjs.GalleryNotFoundError) {
+        return jsonError("Gallery item not found", 404, "NotFound");
+      }
+      throw err;
+    }
+  });
+  const bulkPOST = config.apiWrapper(async (ctx) => {
+    const authorId = getAuthorId(config, ctx);
+    if (!authorId) return jsonError("authentication required", 401, "Unauthorized");
+    const body = await ctx.request.json();
+    const validation = validateAndParse(schemas.BatchCreateGallerySchema, body);
+    if (!validation.success) return validation.response;
+    const result = await service.createMany(validation.data.items, authorId);
+    callRevalidate(config);
+    return _server.NextResponse.json(
+      { success: true, data: result },
+      { status: 201 }
+    );
+  });
+  const bulkPATCH = config.apiWrapper(async (ctx) => {
+    const body = await ctx.request.json();
+    const validation = validateAndParse(schemas.BulkUpdateSchema, body);
+    if (!validation.success) return validation.response;
+    const { ids, published, featured } = validation.data;
+    let count = 0;
+    if (published !== void 0) {
+      const r = await service.bulkUpdatePublished(ids, published);
+      count = r.count;
+    }
+    if (featured !== void 0) {
+      const r = await service.bulkUpdateFeatured(ids, featured);
+      count = r.count;
+    }
+    callRevalidate(config);
+    return _server.NextResponse.json({ success: true, data: { count } });
+  });
+  const categoryCollectionGET = config.apiWrapper(async (ctx) => {
+    const isActiveRaw = getSearchParam(ctx.request, "isActive");
+    const isActive = isActiveRaw === "true" ? true : isActiveRaw === "false" ? false : void 0;
+    const items = await categoryService.list(
+      isActive === void 0 ? void 0 : { isActive }
+    );
+    return _server.NextResponse.json({ success: true, data: items });
+  });
+  const categoryCollectionPOST = config.apiWrapper(async (ctx) => {
+    const body = await ctx.request.json();
+    const validation = validateAndParse(schemas.CreateCategorySchema, body);
+    if (!validation.success) return validation.response;
+    const item = await categoryService.create(validation.data);
+    callRevalidate(config);
+    return _server.NextResponse.json({ success: true, data: item }, { status: 201 });
+  });
+  const categoryItemGET = config.apiWrapper(async (ctx) => {
+    const id = getRouteId(ctx);
+    if (!id) return jsonError("missing route param: id", 400, "InvalidParams");
+    const item = await categoryService.getById(id);
+    if (!item) return jsonError("Category not found", 404, "NotFound");
+    return _server.NextResponse.json({ success: true, data: item });
+  });
+  const categoryItemPUT = config.apiWrapper(async (ctx) => {
+    const id = getRouteId(ctx);
+    if (!id) return jsonError("missing route param: id", 400, "InvalidParams");
+    const body = await ctx.request.json();
+    const validation = validateAndParse(schemas.UpdateCategorySchema, body);
+    if (!validation.success) return validation.response;
+    const existing = await categoryService.getById(id);
+    if (!existing) return jsonError("Category not found", 404, "NotFound");
+    const item = await categoryService.update(id, validation.data);
+    callRevalidate(config);
+    return _server.NextResponse.json({ success: true, data: item });
+  });
+  const categoryItemDELETE = config.apiWrapper(async (ctx) => {
+    const id = getRouteId(ctx);
+    if (!id) return jsonError("missing route param: id", 400, "InvalidParams");
+    try {
+      await categoryService.remove(id);
+    } catch (err) {
+      if (err instanceof _chunkGFOWZGJXjs.CategoryInUseError) {
+        return jsonError(err.message, 409, "CategoryInUse");
+      }
+      throw err;
+    }
+    callRevalidate(config);
+    return new (0, _server.NextResponse)(null, { status: 204 });
+  });
+  return {
+    collection: {
+      GET: collectionGET,
+      POST: collectionPOST,
+      DELETE: collectionDELETE
+    },
+    item: { GET: itemGET, PUT: itemPUT, DELETE: itemDELETE },
+    publishToggle: { PATCH: publishTogglePATCH },
+    bulk: { POST: bulkPOST, PATCH: bulkPATCH },
+    categoryCollection: {
+      GET: categoryCollectionGET,
+      POST: categoryCollectionPOST
+    },
+    categoryItem: {
+      GET: categoryItemGET,
+      PUT: categoryItemPUT,
+      DELETE: categoryItemDELETE
+    }
+  };
+}
+
+// src/server/loaders.ts
+async function getGalleryItems(config, opts) {
+  const service = createGalleryService(config);
+  return service.listAll(opts);
+}
+async function getFeaturedGalleries(config, limit) {
+  const service = createGalleryService(config);
+  return service.listFeatured(limit);
+}
+async function getRecentGalleries(config, limit) {
+  const service = createGalleryService(config);
+  return service.listRecent(limit);
+}
+async function getGalleryCount(config, opts) {
+  const service = createGalleryService(config);
+  return service.count(opts);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CategoryInUseError = _chunkGFOWZGJXjs.CategoryInUseError; exports.CategoryNotFoundError = _chunkGFOWZGJXjs.CategoryNotFoundError; exports.GalleryError = _chunkGFOWZGJXjs.GalleryError; exports.GalleryNotFoundError = _chunkGFOWZGJXjs.GalleryNotFoundError; exports.PermissionDeniedError = _chunkGFOWZGJXjs.PermissionDeniedError; exports.buildPaginatedResult = buildPaginatedResult; exports.createCategoryService = createCategoryService; exports.createGalleryRoutes = createGalleryRoutes; exports.createGalleryService = createGalleryService; exports.getFeaturedGalleries = getFeaturedGalleries; exports.getGalleryConfig = _chunkWVRTM6E7js.getGalleryConfig; exports.getGalleryCount = getGalleryCount; exports.getGalleryItems = getGalleryItems; exports.getRecentGalleries = getRecentGalleries; exports.setGalleryConfig = _chunkWVRTM6E7js.setGalleryConfig;
+//# sourceMappingURL=index.js.map