@strifeapp/astro 1.0.28 → 1.0.30-beta.0

package/README.md

@@ -1,11 +1,7 @@
-# @strifeapp/astro - RECOVERED SOURCE CODE
-
-This source code was recovered from the compiled distribution package v1.0.27.
+# @strifeapp/astro
 
 ## ⚠️ Important Notes
 
-1. **ImageService**: The `src/services/ImageService.ts` file only had type definitions in the compiled version. The actual implementation needs to be filled in based on your requirements.
-
 2. **indexMapping.js**: This file should NOT be converted to TypeScript as it runs inside RavenDB's JavaScript indexing engine. Keep it as plain JavaScript.
 
 3. **Module References**: The vite plugin reads `indexMapping.js` at build time using `readFileSync`, so make sure the path resolution in `vite-plugin-strife-store.ts` is correct for your build setup.

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAI5C,MAAM,WAAW,kBAAmB,SAAQ,YAAY;IACtD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAMD,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,gBAAgB,CAsCxF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAG5C,MAAM,WAAW,kBAAmB,SAAQ,YAAY;IACtD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAMD,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,gBAAgB,CAwBxF"}

package/dist/index.js

@@ -1,30 +1,21 @@
-import { v as _ } from "./vite-plugin-strife-store-B4EtLcP6.js";
-import { loadEnv as l } from "vite";
-const a = {
+import { v as n } from "./vite-plugin-strife-store-DkxIFvv2.js";
+const o = {
   type: "pfx"
 };
-function d(e) {
+function s(t) {
   return {
     name: "@strife/astro",
     hooks: {
-      "astro:config:setup": ({ config: c, updateConfig: f }) => {
-        const E = c.vite.envDir || process.cwd(), { STRIFE_CERTIFICATE: t, STRIFE_CERTIFICATE_PASSWORD: T, STRIFE_DATABASE_URLS: r, STRIFE_DATABASE: S } = l(process.env.NODE_ENV ?? "", E, "");
-        e = {
-          ...e,
-          certificate: t ?? (e == null ? void 0 : e.certificate) ?? a.certificate,
-          password: T ?? (e == null ? void 0 : e.password),
-          urls: r ? r.split(",") : (e == null ? void 0 : e.urls) ?? [],
-          database: S ?? (e == null ? void 0 : e.database)
-        };
-        const A = {
-          ...a,
-          ...e ? Object.fromEntries(
-            Object.entries(e).filter(([u, I]) => !!I)
+      "astro:config:setup": ({ updateConfig: i }) => {
+        const r = {
+          ...o,
+          ...t ? Object.fromEntries(
+            Object.entries(t).filter(([, e]) => e != null)
           ) : {}
         };
-        f({
+        i({
           vite: {
-            plugins: [_(A)]
+            plugins: [n(r)]
           }
         });
       }
@@ -32,5 +23,5 @@ function d(e) {
   };
 }
 export {
-  d as default
+  s as default
 };

package/dist/localized-content-index.js

@@ -0,0 +1,587 @@
+/**
+ * -----------------------------------------------------------------------------
+ *  STRIFE CONTENT INDEX — L10N + StrifeUri + Template-Aware Relations
+ * -----------------------------------------------------------------------------
+ * What this does
+ *   Projects Strife CMS documents into a query‑friendly, localized, relation‑expanded
+ *   shape with one entry per locale. It keeps a deterministic output and a
+ *   centralized storage policy (Corax‑safe).
+ *   Cycle safety and performance caching.
+ *
+ * Canonical root fields (unchanged semantics)
+ *   - id, locale, displayName, url, origin, collection
+ *   - publishedAt, createdAt, changedAt, dependencies, labels, deleted
+ *
+ * Root template (whitelist + localizable)
+ *   - Root fields are populated from the document's template. Scalars marked
+ *     localizable are translated using the current entry's locale and stored.
+ *   - Non‑localizable scalars are index‑only at root.
+ *   - Arrays/objects (relations, chapters, content objects) are stored.
+ *   - Reserved root names can never be redefined by editors.
+ *
+ * Relations (template‑driven for referenced docs)
+ *   - Relations are detected by value shape (array of GUIDs or { id: GUID }).
+ *   - For each referenced GUID, the target document is loaded and projected with
+ *     its template (resolved by collection), using the ROOT entry's locale for
+ *     any localizable scalars.
+ *   - Order is preserved. Only GUIDs are followed. Cycles are prevented via a
+ *     visit cache.
+ *
+ * Nested content by shape (no template loads)
+ *   - Chapters: arrays of small objects; expanded recursively by shape.
+ *   - Content‑template (object): expanded recursively by shape.
+ *   - While expanding by shape, if a field is a relation array by shape, those
+ *     relations are projected via templates (same as above). Otherwise, values
+ *     are copied through. No per‑field localization occurs in shape expansion.
+ *
+ * StrifeUri
+ *   - Form: strife://<docId>.<collection>.<db>/<path>
+ *   - Resolution: loads the target doc and walks the path; the first path
+ *     segment is localized with the ROOT entry's locale. The resolved value can be:
+ *       • a scalar → copied as is
+ *       • an object/array → expanded by shape
+ *       • a relation array → projected via templates
+ *
+ * Storage policy (centralized at root copy step)
+ *   - Arrays/objects → storeAs
+ *   - Scalars localizable at root → storeAs (so projections return translated strings)
+ *   - Scalars not localizable → indexAs (leaner index)
+ *   - Root url is always stored
+ *   - Keep per‑field storage/analyzer consistent across documents (Corax‑safe)
+ *
+ * Caching & cycle safety
+ *   - docCache: documents, tplCache: templates, labelCache: labels
+ *   - visit cache prevents cycles and provides memoization per entry
+ *   - URL builder protects against origin cycles via a local visited set
+ *
+ * Localization model
+ *   - Emits one entry per configured locale.
+ *   - Root scalars marked localizable are translated and stored.
+ *   - Referenced docs projected via templates also translate localizable scalars
+ *     using the ROOT locale. displayName is treated as non‑localized.
+ *   - Shape expansion itself does not localize values, except StrifeUri's first
+ *     path segment at dereference time.
+ *
+ * Determinism & engine constraints
+ *   - ES5‑only (no for..of, no arrow functions).
+ *   - Deterministic shapes under the same inputs.
+ *   - No performance guards (depth/breadth are unbounded); cycles are still safe.
+ * -----------------------------------------------------------------------------
+ */
+
+
+var RESERVED_ROOT_FIELDS = {
+  url: true,
+  collection: true,
+  publishedAt: true,
+  createdAt: true,
+  changedAt: true,
+  labels: true,
+  locale: true,
+  origin: true,
+  id: true,
+  displayName: true,
+  dependencies: true
+};
+
+function storeAs(name, value) {
+  return { $value: value, $name: name, $options: { storage: true } };
+}
+
+function indexAs(name, value) {
+  return { $value: value, $name: name, $options: { storage: false } };
+}
+
+function loadDocCached(id, collection, docCache) {
+  if (!id) return null;
+  var key = collection + '::' + id;
+  if (docCache.has(key)) return docCache.get(key);
+  var d = load(id, collection);
+  if (d) docCache.set(key, d);
+  return d;
+}
+
+function loadTemplateByCollectionCached(collection, tplCache) {
+  if (!collection) return null;
+  var key = 'templates/' + collection;
+  if (tplCache.has(key)) return tplCache.get(key);
+  var t = load(key, 'templates');
+  if (t) tplCache.set(key, t);
+  return t;
+}
+
+function loadTemplateByIdCached(templateId, tplCache) {
+  if (!templateId) return null;
+  var key = templateId;
+  if (tplCache.has(key)) return tplCache.get(key);
+  var t = load(templateId, 'templates');
+  if (t) tplCache.set(key, t);
+  return t;
+}
+
+function loadLocalizationSettings() {
+  return load('configurations/localization', 'configurations');
+}
+
+function loadLabelCached(id, labelCache) {
+  if (!id) return null;
+  if (labelCache.has(id)) return labelCache.get(id);
+  var d = load(id, 'Labels');
+  if (d) labelCache.set(id, d);
+  return d;
+}
+
+function buildUrlCached(doc, docCache) {
+  var visited = {};
+  var slugs = [];
+  var c = doc;
+  do {
+    if (c.slug) slugs.unshift(c.slug);
+    if (!c.origin || visited[c.origin.id]) break;
+    visited[c.origin.id] = true;
+    c = loadDocCached(c.origin.id, c.origin.collection, docCache);
+  } while (c);
+
+  return slugs.shift() + slugs.join('/');
+}
+
+function getTranslator(locale, defaultLocale, fallbackToPrimary) {
+  return function (obj) {
+    if (!obj) return null;
+    if (typeof obj === 'object' && obj.hasOwnProperty) {
+      if (obj.hasOwnProperty(locale)) return obj[locale];
+      // if (fallbackToPrimary && locale && locale.length > 2) {
+      //   var base = locale.slice(0, 2);
+      //   if (obj.hasOwnProperty(base)) return obj[base];
+      // }
+      //return obj[defaultLocale];
+    }
+    return null;
+  };
+}
+
+function isGuid(s) {
+  return typeof s === 'string' &&
+         /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(s);
+}
+function isRefLike(x) {
+  // GUID string id, or object with GUID `id`
+  if (typeof x === 'string') return isGuid(x);
+  if (!x || typeof x !== 'object') return false;
+  return typeof x.id === 'string' && isGuid(x.id) && Object.keys(x).length <= 2;
+}
+function isRelationArray(v) {
+  if (!v || !Array.isArray(v)) return false;
+  if (v.length === 0) return false; // empty arrays are ambiguous
+  for (var i = 0; i < v.length; i++) {
+    if (!isRefLike(v[i])) return false;
+  }
+  return true;
+}
+
+var strifeUriPattern = /^strife:\/\/(?<id>[-\w_]*)\.(?<coll>[\w_-]*)\.(?<db>[\w_-]*)(?<path>[-\w_./]*)?$/;
+function isStrifeUri(value) {
+  var match = strifeUriPattern.exec(value || '');
+  if (!match) return null;
+  try {
+    var path = match.groups.path || '';
+    var segs = path.length > 1 ? path.slice(1).split('/') : [];
+    return {
+      original: value,
+      db: match.groups.db,
+      collection: match.groups.coll,
+      docId: match.groups.id,           // may be non-GUID by design for StrifeUri
+      segments: segs
+    };
+  } catch (e) {
+    return null;
+  }
+}
+
+function tryGetReferencedValue(strifeUri, populationContext, docCache) {
+  var document = loadDocCached(strifeUri.docId, '@all_docs', docCache);
+  if (!document) return null;
+
+  var val = document;
+  if (strifeUri.segments.length > 0) {
+    // first segment may be localized
+    var first = strifeUri.segments[0];
+    val = populationContext.translate(val[first]);
+    for (var i = 1; i < strifeUri.segments.length; i++) {
+      if (val == null) break;
+      var segment = strifeUri.segments[i];
+      val = val[segment];
+    }
+  }
+  return val;
+}
+
+function resolveStrifeUriIfAny(value, populationContext, docCache) {
+  var maybeUri = isStrifeUri(value);
+  return maybeUri ? tryGetReferencedValue(maybeUri, populationContext, docCache) : value;
+}
+
+function loadRelatedLabels(labelIdsArray, labelCache) {
+  if (!labelIdsArray || !labelIdsArray.length) return null;
+  var out = [];
+  for (var i = 0; i < labelIdsArray.length; i++) {
+    var lid = labelIdsArray[i];
+    var d = loadLabelCached(lid, labelCache);
+    if (d) out.push(d);
+  }
+  return out;
+}
+
+function getVisitEntry(visit, id) {
+  var e = visit.get(id);
+  if (!e) { e = { state: 'done', node: null }; visit.set(id, e); }
+  return e;
+}
+
+function isVisiting(visit, id) {
+  var e = visit.get(id);
+  return e ? e.state === 'visiting' : false;
+}
+
+function markVisiting(visit, id) {
+  var e = getVisitEntry(visit, id);
+  e.state = 'visiting';
+}
+
+function markDone(visit, id) {
+  var e = getVisitEntry(visit, id);
+  e.state = 'done';
+}
+
+function getCachedNode(visit, id) {
+  var e = visit.get(id);
+  return e && e.node ? e.node : null;
+}
+
+function setCachedNode(visit, id, node) {
+  var e = getVisitEntry(visit, id);
+  e.node = node;
+}
+
+function isContentTemplateNode(v) {
+  return v && typeof v === 'object' && !Array.isArray(v) &&
+         v['@strife'] && v['@strife'].template;
+}
+
+function isChaptersArray(v) {
+  if (!v || !Array.isArray(v)) return false;
+  if (v.length === 0) return false;
+  for (var i = 0; i < v.length; i++) {
+    var it = v[i];
+    if (!it || !it['@strife'] || !it['@strife'].template) return false;
+  }
+  return true;
+}
+
+function populateByShape(document, out, populationContext, visit,
+                         docCache, tplCache, labelCache) {
+  if (!document || typeof document !== 'object') return;
+
+  for (var prop in document) {
+    if (!document || !document.hasOwnProperty || !document.hasOwnProperty(prop)) continue;
+
+    // Keep metadata decorations as-is
+    if (prop.charAt(0) === '@') { out[prop] = document[prop]; continue; }
+
+    var val = document[prop];
+    // StrifeUri resolution
+    val = resolveStrifeUriIfAny(val, populationContext, docCache);
+
+    // Chapters
+    if (isChaptersArray(val)) {
+      var arr = [];
+      for (var ci = 0; ci < val.length; ci++) {
+        var chapter = val[ci];
+        if (chapter && chapter['@strife'] && chapter['@strife'].template) {
+          var child = {};
+          populateByShape(chapter, child, populationContext, visit,
+                          docCache, tplCache, labelCache);
+          arr.push(child);
+        }
+      }
+      out[prop] = arr;
+      continue;
+    }
+
+    // Content-template node
+    if (isContentTemplateNode(val)) {
+      var nested = {};
+      populateByShape(val, nested, populationContext, visit,
+                      docCache, tplCache, labelCache);
+      out[prop] = nested;
+      continue;
+    }
+
+    // Relations (GUID-strict)
+    if (isRelationArray(val)) {
+      var related = projectRelationsIfAny(val, populationContext, visit, docCache, tplCache, labelCache);
+      if (related) { out[prop] = related; continue; }
+    }
+
+    // Default: copy-through (no localization inside nested)
+    out[prop] = val;
+  }
+
+  if (document['@strife'] && !out['@strife']) out['@strife'] = document['@strife'];
+}
+
+function projectRelationsIfAny(value, populationContext, visit, docCache, tplCache, labelCache) {
+  if (!isRelationArray(value)) return null;
+  var refs = [];
+  for (var i = 0; i < value.length; i++) {
+    var v = value[i];
+    var idStr = (typeof v === 'string') ? v : (v && v.id);
+    if (isGuid(idStr)) refs.push(idStr);
+  }
+  return loadRelatedDocumentsRecurse(refs, populationContext, visit, docCache, tplCache, labelCache);
+}
+
+function populateValuesByEditor(document, template, result, populationContext, visit,
+                                docCache, tplCache, labelCache, isRootLevel) {
+  if (!template || !template.editors) return;
+  var tEditors = template.editors || [];
+  var i, editor;
+
+  function processEditor(editor, isRoot) {
+    if (!editor || !editor.editor || !editor.editor.propertyName) return;
+
+    var propertyName = editor.editor.propertyName;
+
+    // Never let editors redefine reserved fields (consistent everywhere)
+    if (RESERVED_ROOT_FIELDS[propertyName]) return;
+
+    // Read value with optional localization
+    var rawVal = document[propertyName];
+    var docValue = (editor.localizable) ? populationContext.translate(rawVal) : rawVal;
+
+    // StrifeUri resolution
+    docValue = resolveStrifeUriIfAny(docValue, populationContext, docCache);
+
+    // Relations (GUID-strict) — detect by value shape
+    var relatedDocs = projectRelationsIfAny(docValue, populationContext, visit, docCache, tplCache, labelCache);
+    if (relatedDocs) { result[propertyName] = relatedDocs; return; }
+
+    // Chapters (nested without template loads)
+    if (editor.editor.type === 'chapters') {
+      if (docValue == null) {                // missing translation
+        result[propertyName] = null;         // keep null instead of dropping field
+        return;
+      }
+      if (!Array.isArray(docValue)) return;
+      var docResults = [];
+      for (var ci = 0; ci < docValue.length; ci++) {
+        var chapter = docValue[ci];
+        if (chapter && chapter['@strife'] && chapter['@strife'].template) {
+          var child = {};
+          populateByShape(chapter, child, populationContext, visit,
+                          docCache, tplCache, labelCache);
+          docResults.push(child);
+        }
+      }
+      result[propertyName] = docResults;
+      return;
+    }
+
+    // Content-template (nested without template loads)
+    if (editor.editor.type === 'content-template') {
+      if (docValue == null) {                // missing translation
+        result[propertyName] = null;
+        return;
+      }
+      if (docValue && typeof docValue === 'object') {
+        var nested = {};
+        populateByShape(docValue, nested, populationContext, visit,
+                        docCache, tplCache, labelCache);
+        result[propertyName] = nested;
+      }
+      return;
+    }
+
+    // Other fields: plain values (localized at root when editor.localizable)
+    if (docValue !== undefined) {
+      result[propertyName] = docValue;
+    }
+  }
+
+  for (i = 0; i < tEditors.length; i++) {
+    processEditor(tEditors[i], isRootLevel);
+  }
+
+  if (document['@strife']) result['@strife'] = document['@strife'];
+}
+
+function projectDocumentWithTemplate(doc, populationContext, visit,
+                                     docCache, tplCache, labelCache) {
+  var collection = doc && doc['@metadata'] ? doc['@metadata']['@collection'] : null;
+  var tpl = loadTemplateByCollectionCached(collection, tplCache);
+  var labelsArr = Array.isArray(doc.labels) ? doc.labels : null;
+
+  var result = {
+    id: Id(doc),
+    url: buildUrlCached(doc, docCache),
+    collection: collection,
+    displayName: doc.displayName,
+    slug: doc.slug,
+    publishedDate: doc.publishedDate,
+    labels: loadRelatedLabels(labelsArr, labelCache)
+  };
+
+  // Fill fields per template (use root locale via populationContext.translate)
+  if (tpl && tpl.editors) {
+    populateValuesByEditor(doc, tpl, result, populationContext, visit,
+                           docCache, tplCache, labelCache, false);
+  }
+
+  return result;
+}
+
+function loadRelatedDocumentsRecurse(refGuids, populationContext, visit,
+                                     docCache, tplCache, labelCache) {
+  if (!refGuids) return null;
+
+  var results = [];
+  for (var i = 0; i < refGuids.length; i++) {
+    var id = refGuids[i];
+    if (!isGuid(id)) continue;
+
+    if (isVisiting(visit, id)) continue;
+
+    var cached = getCachedNode(visit, id);
+    if (cached) { results.push(cached); continue; }
+
+    markVisiting(visit, id);
+    var doc = loadDocCached(id, '@all_docs', docCache);
+
+    if (doc) {
+      var projected = projectDocumentWithTemplate(doc, populationContext, visit,
+                                                 docCache, tplCache, labelCache);
+      setCachedNode(visit, id, projected);
+      results.push(projected);
+    }
+
+    markDone(visit, id);
+  }
+
+  return results;
+}
+
+function mapDocument(document) {
+  var collection = document['@metadata']['@collection'];
+  var template = load('templates/' + collection, 'templates');
+  if (!template || !template.editors || document.deleted || document.archived) return null;
+
+  var l10n = loadLocalizationSettings();
+  var locales = (l10n && Array.isArray(l10n.locales)) ? l10n.locales : [l10n && l10n.defaultLocale ? l10n.defaultLocale : 'en'];
+
+  // Shared per-document caches (shared across locales)
+  var _docCache   = new Map();
+  var _tplCache   = new Map();
+  var _labelCache = new Map();
+
+  var entries = [];
+
+  // Precompute root labels (loaded in helper)
+  var rootLabelIds = Array.isArray(document.labels) ? document.labels : null;
+
+  // Precompute dependencies (ES5)
+  var depsArr = [];
+  if (document.dependencies && Array.isArray(document.dependencies)) {
+    for (var di = 0; di < document.dependencies.length; di++) {
+      var dep = document.dependencies[di];
+      if (dep && typeof dep.id === 'string') depsArr.push(dep.id);
+    }
+  }
+
+  // Build a set of localizable root scalar fields from the template
+  var localizableRoot = {};
+  if (template && template.editors) {
+    for (var li0 = 0; li0 < template.editors.length; li0++) {
+      var ed0 = template.editors[li0];
+      if (!ed0 || !ed0.editor || !ed0.editor.propertyName) continue;
+      var t0 = ed0.editor.type;
+      if (t0 !== 'related' && t0 !== 'references' && t0 !== 'content-template' && t0 !== 'chapters') {
+        if (ed0.localizable === true) localizableRoot[ed0.editor.propertyName] = true;
+      }
+    }
+  }
+
+  for (var li = 0; li < locales.length; li++) {
+
+    var currentLocale = locales[li];
+    if (document.locales && Array.isArray(document.locales)) {
+      var found = false;
+      for (var k = 0; k < document.locales.length; k++) {
+        if (document.locales[k] === currentLocale) { found = true; break; }
+      }
+      if (!found) continue;
+    }
+
+    var translate = getTranslator(currentLocale, l10n.defaultLocale, l10n.fallbackToPrimary);
+
+    // Root result (stored fields)
+    var result = {
+      id: Id(document),
+      locale: storeAs('locale', currentLocale),
+      displayName: document.displayName,
+      url: template.disableURL ? null : storeAs('url', buildUrlCached(document, _docCache)),
+      origin: storeAs('origin', document.origin ? document.origin.id : null ),
+      collection: storeAs('collection', collection),
+      publishedDate: storeAs('publishedAt', document.publishedDate),
+      createdAt: storeAs('createdAt', document.createdAt),
+      changedAt: storeAs('changedAt', document.changedAt),
+      dependencies: storeAs('dependencies', depsArr),
+      //labels: storeAs('labels', loadRelatedLabels(rootLabelIds, _labelCache)),
+      labels: storeAs('labels', loadRelatedLabels(rootLabelIds, _labelCache).map(label => label.name)),
+      deleted: document.deleted
+    };
+
+    // Visit cache per-locale (keeps shapes deterministic per entry)
+    var visit = new Map();
+
+    // Build dynamic fields into a temp container using ROOT TEMPLATE (respect localizable)
+    var rootContainer = {};
+    populateValuesByEditor(document, template, rootContainer, { translate: translate },
+                           visit, _docCache, _tplCache, _labelCache, true);
+
+    // Copy fields from temp container into result
+    // - arrays/objects -> storeAs
+    // - scalars -> storeAs if localizable, else indexAs
+    var keys = [];
+    for (var key in rootContainer) {
+      if (rootContainer && rootContainer.hasOwnProperty && rootContainer.hasOwnProperty(key)) {
+        keys.push(key);
+      }
+    }
+
+    for (var ei = 0; ei < keys.length; ei++) {
+      var prop = keys[ei];
+
+      // never redefine canonical root fields
+      if (RESERVED_ROOT_FIELDS[prop]) continue;
+
+      var val = rootContainer[prop];
+      var isArray = Array.isArray(val);
+      var isProjectedArray  = isArray && (val.length === 0 || typeof val[0] === 'object');
+      var isProjectedObject = !isArray && typeof val === 'object';
+
+      if (isProjectedArray || isProjectedObject) {
+        result[prop] = storeAs(prop, val);
+      } else {
+        if (localizableRoot[prop] === true) {
+          result[prop] = storeAs(prop, val);   // translated scalar → store so projections return translated value
+        } else {
+          result[prop] = indexAs(prop, val);   // non-localizable scalar → index-only
+        }
+      }
+    }
+
+    entries.push(result);
+  }
+
+  return entries;
+}

package/dist/vite-plugin-strife-store-DkxIFvv2.js

@@ -0,0 +1,89 @@
+import { readFileSync as a } from "fs";
+import { dirname as l, resolve as f } from "path";
+import { fileURLToPath as u } from "url";
+import t from "serialize-javascript";
+const n = "strife:store", o = "\0" + n;
+function g(i) {
+  const s = u(import.meta.url), c = l(s), r = a(
+    f(c, "./localized-content-index.js"),
+    "utf-8"
+  );
+  return {
+    name: "strife:store",
+    resolveId(e) {
+      if (e === n)
+        return o;
+    },
+    load(e) {
+      if (e === o)
+        return `
+          import { DocumentStore, AbstractJavaScriptMultiMapIndexCreationTask } from "ravendb";
+
+          const indexMappingSource = ${t(r)};
+          const defaultConfig = ${t(i)};
+
+          const urls = process.env.STRIFE_DATABASE_URLS
+            ? process.env.STRIFE_DATABASE_URLS.split(',')
+            : (defaultConfig.urls || []);
+
+          const database = process.env.STRIFE_DATABASE || defaultConfig.database || '';
+
+          const certificate = process.env.STRIFE_CERTIFICATE || defaultConfig.certificate;
+          const password = process.env.STRIFE_CERTIFICATE_PASSWORD || defaultConfig.password;
+
+          const hasAuth = certificate && password;
+
+          const authOptions = hasAuth ? {
+            type: defaultConfig.type || 'pfx',
+            certificate: Buffer.from(certificate, 'base64'),
+            password,
+          } : null;
+
+          const store = new DocumentStore(
+            urls,
+            database,
+            authOptions || undefined,
+          ).initialize();
+
+          class Content_ByUrl extends AbstractJavaScriptMultiMapIndexCreationTask {
+            constructor() {
+              super();
+
+              this.additionalSources = {"Helper": indexMappingSource};
+
+              const collections = (defaultConfig.collections && defaultConfig.collections.length)
+                ? defaultConfig.collections
+                : ['Posts'];
+
+              for (const collection of collections) {
+                const name = typeof collection === 'string' ? collection : collection.name;
+                this.map(name, function (doc) { return mapDocument(doc); });
+              }
+
+              this.deploymentMode = 'Rolling';
+              this.searchEngineType = 'Lucene';
+            }
+          }
+
+          console.log('Deploying index...');
+
+          await store.executeIndex(new Content_ByUrl());
+
+          const bulkInsert = store.bulkInsert();
+
+          if (defaultConfig.collections && defaultConfig.collections.length) {
+            for (const collection of defaultConfig.collections) {
+              await bulkInsert.store(collection, 'templates/' + collection.name, { '@collection': 'Templates' });
+            }
+          }
+
+          await bulkInsert.finish();
+
+          export { store };
+        `;
+    }
+  };
+}
+export {
+  g as v
+};

package/dist/vite-plugin-strife-store-entry.js

@@ -1,4 +1,4 @@
-import { v as t } from "./vite-plugin-strife-store-B4EtLcP6.js";
+import { v as t } from "./vite-plugin-strife-store-DkxIFvv2.js";
 export {
   t as vitePluginStrifeStore
 };

package/dist/vite-plugin-strife-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vite-plugin-strife-store.d.ts","sourceRoot":"","sources":["../src/vite-plugin-strife-store.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAEzC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAKlD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,kBAAkB,GAAG,YAAY,CAmE9E"}
+{"version":3,"file":"vite-plugin-strife-store.d.ts","sourceRoot":"","sources":["../src/vite-plugin-strife-store.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAEzC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAKlD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,kBAAkB,GAAG,YAAY,CAsF9E"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strifeapp/astro",
-  "version": "1.0.28",
+  "version": "1.0.30-beta.0",
   "description": "Official Strife Astro integration",
   "keywords": [
     "astro-integration",

package/dist/vite-plugin-strife-store-B4EtLcP6.js

@@ -1,73 +0,0 @@
-import { readFileSync as c } from "fs";
-import { dirname as m, resolve as u } from "path";
-import { fileURLToPath as d } from "url";
-import r from "serialize-javascript";
-const n = "strife:store", o = "\0" + n;
-function S(e) {
-  const i = d(import.meta.url), p = m(i), l = c(
-    u(p, "../../../../../../../data/ravendb/localized-content-index.js"),
-    "utf-8"
-  );
-  return {
-    name: "strife:store",
-    resolveId(s) {
-      if (s === n)
-        return o;
-    },
-    load(s) {
-      var a;
-      if (s === o)
-        return `
-          import { DocumentStore, AbstractJavaScriptMultiMapIndexCreationTask } from "ravendb";
-
-          ${e.certificate && e.password ? `
-          const authOptions = {
-            type: 'pfx',
-            certificate: Buffer.from(${r(e.certificate)}, 'base64'),
-            password: ${r(e.password)},
-          };
-          ` : ""}
-
-          const store = new DocumentStore(
-            ${r(e.urls ? e.urls : [])},
-            ${r(e.database || "")}${e.certificate && e.password ? `,
-            authOptions` : ""}
-          ).initialize()
-
-          class Content_ByUrl extends AbstractJavaScriptMultiMapIndexCreationTask {
-            constructor() {
-              super();
-
-              this.additionalSources = {"Helper": ${r(l)}}
-
-              ${(e.collections || ["Posts"]).map(
-          (t) => `this.map("${typeof t == "string" ? t : t.name}", (doc) =>  { return mapDocument(doc) });`
-        ).join(`
-`)}
-
-              this.deploymentMode = 'Rolling';
-              this.searchEngineType = 'Lucene';
-            }
-          }
-
-          console.log('Deploying index...');
-
-          await store.executeIndex(new Content_ByUrl());
-
-          const bulkInsert = store.bulkInsert();
-
-          ${(a = e.collections) == null ? void 0 : a.map((t) => `
-            await bulkInsert.store(${JSON.stringify(t)}, 'templates/${t.name}', { '@collection': 'Templates' });
-          `).join(`
-`)}
-
-          await bulkInsert.finish();
-
-          export { store };
-        `;
-    }
-  };
-}
-export {
-  S as v
-};