@arcote.tech/arc 0.3.4 → 0.3.5

package/dist/context-element/index.d.ts

@@ -8,5 +8,12 @@ export * from "./context-element";
 export * from "./event";
 export * from "./listener";
 export * from "./route";
+export * from "./static-view";
 export * from "./view";
+import type { ArcStaticViewAny, ArcStaticViewRecord } from "./static-view";
+import type { ArcViewAny, ArcViewRecord } from "./view";
+/**
+ * Helper type to extract record type from any view (regular or static)
+ */
+export type ArcAnyViewRecord<View extends ArcViewAny | ArcStaticViewAny> = View extends ArcViewAny ? ArcViewRecord<View> : View extends ArcStaticViewAny ? ArcStaticViewRecord<View> : never;
 //# sourceMappingURL=index.d.ts.map

package/dist/context-element/static-view/static-view.d.ts

@@ -104,7 +104,7 @@ export declare class ArcStaticView<const Data extends ArcStaticViewData> extends
 export declare function staticView<const Name extends string, Id, Schema extends ArcObjectAny | ArcRawShape>(name: Name, id: Id, schema: Schema): ArcStaticView<{
     name: Name;
     id: Id;
-    schema: ArcObject<ArcRawShape, [{
+    schema: (Schema & ArcObject<any, any>) | ArcObject<ArcRawShape, [{
         name: "type";
         validator: (value: any) => false | {
             current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
@@ -115,7 +115,7 @@ export declare function staticView<const Name extends string, Id, Schema extends
         validator: (value: any) => false | {
             [x: string]: unknown;
         };
-    }]> | (Schema & ArcObject<any, any>);
+    }]>;
     items: [];
 }>;
 /**

package/dist/index.js

@@ -1931,6 +1931,84 @@ function route(name) {
     isPublic: false
   });
 }
+// src/context-element/static-view/static-view.ts
+class ArcStaticView extends ArcContextElement {
+  data;
+  constructor(data) {
+    super(data.name);
+    this.data = data;
+  }
+  get id() {
+    return this.data.id;
+  }
+  get schema() {
+    return this.data.schema;
+  }
+  get items() {
+    return this.data.items;
+  }
+  description(description) {
+    return new ArcStaticView({
+      ...this.data,
+      description
+    });
+  }
+  addItems(items) {
+    return new ArcStaticView({
+      ...this.data,
+      items
+    });
+  }
+  queryContext(_adapters) {
+    const items = this.data.items;
+    return {
+      find: async (options) => {
+        let results = [...items];
+        if (options?.where) {
+          results = results.filter((item) => this.matchesWhere(item, options.where));
+        }
+        if (options?.orderBy) {
+          const entries = Object.entries(options.orderBy);
+          results.sort((a, b) => {
+            for (const [key, direction] of entries) {
+              const aVal = a[key];
+              const bVal = b[key];
+              if (aVal < bVal)
+                return direction === "asc" ? -1 : 1;
+              if (aVal > bVal)
+                return direction === "asc" ? 1 : -1;
+            }
+            return 0;
+          });
+        }
+        if (options?.limit) {
+          results = results.slice(0, options.limit);
+        }
+        return results;
+      },
+      findOne: async (where) => {
+        if (!where)
+          return items[0];
+        const item = items.find((item2) => this.matchesWhere(item2, where));
+        return item;
+      }
+    };
+  }
+  matchesWhere(item, where) {
+    return Object.entries(where).every(([key, value]) => {
+      return item[key] === value;
+    });
+  }
+}
+function staticView(name, id2, schema) {
+  const schemaObj = schema instanceof ArcObject ? schema : new ArcObject(schema);
+  return new ArcStaticView({
+    name,
+    id: id2,
+    schema: schemaObj,
+    items: []
+  });
+}
 // src/context-element/view/view.ts
 class ArcView extends ArcContextElement {
   data;
@@ -3756,17 +3834,25 @@ class StreamingEventPublisher {
   }
 }
 // src/streaming/streaming-live-query.ts
+function isStaticView(element2) {
+  return element2 && "items" in element2 && !("getHandlers" in element2);
+}
 function streamingLiveQuery(model, queryFn, callback, options) {
   const { queryWire, cache, authToken } = options;
   let currentResult = undefined;
   const unsubscribers = [];
   const queriedViews = new Set;
+  const staticViews = new Set;
   const queryContext = new Proxy({}, {
     get(_target, viewName) {
       const element2 = model.context.get(viewName);
       if (!element2) {
         throw new Error(`View '${viewName}' not found in context`);
       }
+      if (isStaticView(element2)) {
+        staticViews.add(viewName);
+        return element2.queryContext(model.getAdapters());
+      }
       queriedViews.add(viewName);
       return {
         find: async (findOptions = {}) => {
@@ -3787,7 +3873,12 @@ function streamingLiveQuery(model, queryFn, callback, options) {
   };
   const setupStreams = async () => {
     queriedViews.clear();
+    staticViews.clear();
     await queryFn(queryContext);
+    if (queriedViews.size === 0 && staticViews.size > 0) {
+      executeQuery();
+      return;
+    }
     for (const viewName of queriedViews) {
       const store = cache.getStore(viewName);
       const cacheUnsub = store.subscribe(() => {
@@ -4246,6 +4337,7 @@ export {
   stringEnum,
   string,
   streamingLiveQuery,
+  staticView,
   secureDataStorage,
   route,
   resolveQueryChange,
@@ -4299,6 +4391,7 @@ export {
   ArcToken,
   ArcStringEnum,
   ArcString,
+  ArcStaticView,
   ArcRoute,
   ArcRecord,
   ArcOr,

package/dist/streaming/streaming-live-query.d.ts

@@ -4,6 +4,7 @@
  * Uses SSE stream to get initial data and updates from server.
  * Uses StreamingQueryCache for local state and reactivity.
  * Deduplicates SSE streams - multiple queries on same view share one stream.
+ * Static views are handled directly without SSE.
  */
 import type { QueryWire } from "../adapters/query-wire";
 import type { ArcContextAny } from "../context/context";
@@ -20,6 +21,7 @@ export interface StreamingLiveQueryOptions {
  *
  * Opens SSE stream to server, populates cache, and reacts to changes.
  * Reuses existing streams for the same view (deduplication via cache).
+ * Static views return data directly without SSE.
  */
 export declare function streamingLiveQuery<C extends ArcContextAny, TResult>(model: Model<C>, queryFn: (q: QueryContext<C>) => Promise<TResult>, callback: (data: TResult) => void, options: StreamingLiveQueryOptions): LiveQueryResult<TResult>;
 //# sourceMappingURL=streaming-live-query.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc",
   "type": "module",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "description": "Arc framework core rewrite with improved event emission and type safety",