@gbl-uzh/platform 0.2.10

package/dist/lib/apollo.d.ts

@@ -0,0 +1,4 @@
+declare function initializeApollo(initialState?: null): any;
+declare function useApollo(initialState: any): any;
+
+export { initializeApollo, useApollo };

package/dist/lib/apollo.js

@@ -0,0 +1,119 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/apollo.ts
+var apollo_exports = {};
+__export(apollo_exports, {
+  initializeApollo: () => initializeApollo,
+  useApollo: () => useApollo
+});
+module.exports = __toCommonJS(apollo_exports);
+var import_client = require("@apollo/client");
+var import_http = require("@apollo/client/link/http");
+var import_utilities = require("@apollo/client/utilities");
+var import_config = __toESM(require("next/config"));
+var import_react = require("react");
+
+// src/lib/SSELink.ts
+var import_core = require("@apollo/client/core");
+var import_graphql = require("graphql");
+var SSELink = class extends import_core.ApolloLink {
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  request(operation) {
+    const url = new URL(this.options.url);
+    url.searchParams.append("query", (0, import_graphql.print)(operation.query));
+    url.searchParams.append("variables", JSON.stringify(operation.variables));
+    return new import_core.Observable((sink) => {
+      const eventsource = new EventSource(url.toString(), this.options);
+      eventsource.onmessage = function(event) {
+        const data = JSON.parse(event.data);
+        sink.next(data);
+        if (eventsource.readyState === 2) {
+          sink.complete();
+        }
+      };
+      eventsource.onerror = function(error) {
+        sink.error(error);
+      };
+      return () => eventsource.close();
+    });
+  }
+};
+var SSELink_default = SSELink;
+
+// src/lib/apollo.ts
+var apolloClient;
+function createIsomorphLink() {
+  const { publicRuntimeConfig, serverRuntimeConfig } = (0, import_config.default)();
+  const isBrowser = typeof window !== "undefined";
+  let httpLink = new import_http.HttpLink({
+    uri: publicRuntimeConfig.apiURL,
+    credentials: "same-origin"
+  });
+  if (isBrowser) {
+    const sseLink = new SSELink_default({
+      url: publicRuntimeConfig.apiURL
+    });
+    httpLink = (0, import_client.split)(
+      ({ query }) => {
+        const { kind, operation } = (0, import_utilities.getMainDefinition)(query);
+        return kind === "OperationDefinition" && operation === "subscription";
+      },
+      sseLink,
+      httpLink
+    );
+  }
+  return httpLink;
+}
+function createApolloClient() {
+  return new import_client.ApolloClient({
+    ssrMode: typeof window === "undefined",
+    link: createIsomorphLink(),
+    cache: new import_client.InMemoryCache()
+  });
+}
+function initializeApollo(initialState = null) {
+  const _apolloClient = apolloClient ?? createApolloClient();
+  if (initialState) {
+    _apolloClient.cache.restore(initialState);
+  }
+  if (typeof window === "undefined")
+    return _apolloClient;
+  if (!apolloClient)
+    apolloClient = _apolloClient;
+  return _apolloClient;
+}
+function useApollo(initialState) {
+  const store = (0, import_react.useMemo)(() => initializeApollo(initialState), [initialState]);
+  return store;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initializeApollo,
+  useApollo
+});

package/dist/lib/util.d.ts

@@ -0,0 +1,4 @@
+declare function setDifference(a: any, b: any, filterNoId?: boolean): any;
+declare function setIntersection(a: any, b: any): any;
+
+export { setDifference, setIntersection };

package/dist/lib/util.js

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/util.ts
+var util_exports = {};
+__export(util_exports, {
+  setDifference: () => setDifference,
+  setIntersection: () => setIntersection
+});
+module.exports = __toCommonJS(util_exports);
+function setDifference(a, b, filterNoId = false) {
+  if (!b)
+    return a;
+  const A = a || [];
+  const B = new Set(b.map((item) => item.id));
+  return A.filter((item) => !B.has(item.id) || filterNoId && !item.id);
+}
+function setIntersection(a, b) {
+  if (!a || !b)
+    return [];
+  const B = new Set(b.map((item) => item.id));
+  return a.filter((item) => B.has(item.id) && item.id);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setDifference,
+  setIntersection
+});

package/dist/nexus.d.ts

@@ -0,0 +1,78 @@
+import * as nexus_dist_core from 'nexus/dist/core';
+import * as yup from 'yup';
+
+declare const GameStatus: nexus_dist_core.NexusEnumTypeDef<"GameStatus">;
+declare const Game: nexus_dist_core.NexusObjectTypeDef<"Game">;
+declare const Period: nexus_dist_core.NexusObjectTypeDef<"Period">;
+declare const PeriodSegment: nexus_dist_core.NexusObjectTypeDef<"PeriodSegment">;
+
+declare const LearningAnswerOption: nexus_dist_core.NexusObjectTypeDef<"LearningAnswerOption">;
+declare const LearningElementState: nexus_dist_core.NexusObjectTypeDef<"LearningElementState">;
+declare const LearningElementAttempt: nexus_dist_core.NexusObjectTypeDef<"LearningElementAttempt">;
+declare const LearningElement: nexus_dist_core.NexusObjectTypeDef<"LearningElement">;
+
+interface GenerateBaseMutationsArgs {
+    reducers?: any;
+    roleAssigner?: (ix: number) => void;
+}
+declare function generateBaseMutations({ reducers, roleAssigner, }?: GenerateBaseMutationsArgs): nexus_dist_core.NexusObjectTypeDef<"Mutation">;
+declare const Mutation: nexus_dist_core.NexusObjectTypeDef<"Mutation">;
+
+declare const PeriodFactsSchema: yup.ObjectSchema<{
+    spotTradingEnabled: boolean;
+    futuresTradingEnabled: boolean;
+    optionsTradingEnabled: boolean;
+    interestRate: number;
+    convenienceYield: number;
+    storageCostPerItem: number;
+    initialSpotPrice: number | undefined;
+    randomSeed: number | undefined;
+    trendE: number;
+    trendGap: number;
+}, yup.AnyObject, {
+    spotTradingEnabled: true;
+    futuresTradingEnabled: false;
+    optionsTradingEnabled: false;
+    interestRate: 0.01;
+    convenienceYield: 0.008;
+    storageCostPerItem: 50;
+    initialSpotPrice: undefined;
+    randomSeed: undefined;
+    trendE: 0.005;
+    trendGap: 0.02;
+}, "">;
+interface PeriodFacts extends yup.InferType<typeof PeriodFactsSchema> {
+}
+declare const PeriodFactsInput: nexus_dist_core.NexusInputObjectTypeDef<"PeriodFactsInput">;
+declare const PeriodSegmentFactsSchema: yup.ObjectSchema<{
+    trendE: number | undefined;
+    trendGap: number | undefined;
+}, yup.AnyObject, {
+    trendE: undefined;
+    trendGap: undefined;
+}, "">;
+interface PeriodSegmentFacts extends yup.InferType<typeof PeriodSegmentFactsSchema> {
+}
+declare const PeriodSegmentFactsInput: nexus_dist_core.NexusInputObjectTypeDef<"PeriodSegmentFactsInput">;
+
+declare const PlayerDecisionType: nexus_dist_core.NexusEnumTypeDef<"PlayerDecisionType">;
+declare const PlayerResultType: nexus_dist_core.NexusEnumTypeDef<"PlayerResultType">;
+declare const PlayerLevel: nexus_dist_core.NexusObjectTypeDef<"PlayerLevel">;
+declare const PlayerState: nexus_dist_core.NexusObjectTypeDef<"PlayerState">;
+declare const Player: nexus_dist_core.NexusObjectTypeDef<"Player">;
+declare const PlayerResult: nexus_dist_core.NexusObjectTypeDef<"PlayerResult">;
+declare const PlayerAction: nexus_dist_core.NexusObjectTypeDef<"PlayerAction">;
+declare const PlayerDecision: nexus_dist_core.NexusObjectTypeDef<"PlayerDecision">;
+
+declare function generateBaseQueries(): nexus_dist_core.NexusObjectTypeDef<"Query">;
+declare const Query: nexus_dist_core.NexusObjectTypeDef<"Query">;
+
+declare function generateBaseSubscriptions(): nexus_dist_core.NexusObjectTypeDef<string>;
+declare const Subscription: nexus_dist_core.NexusObjectTypeDef<string>;
+
+declare const JsonScalar: nexus_dist_core.AllNexusOutputTypeDefs;
+declare const DateScalar: nexus_dist_core.AllNexusOutputTypeDefs;
+declare const UserRole: nexus_dist_core.NexusEnumTypeDef<"UserRole">;
+declare const Event: nexus_dist_core.NexusObjectTypeDef<"Event">;
+
+export { DateScalar, Event, Game, GameStatus, JsonScalar, LearningAnswerOption, LearningElement, LearningElementAttempt, LearningElementState, Mutation, Period, PeriodFacts, PeriodFactsInput, PeriodFactsSchema, PeriodSegment, PeriodSegmentFacts, PeriodSegmentFactsInput, PeriodSegmentFactsSchema, Player, PlayerAction, PlayerDecision, PlayerDecisionType, PlayerLevel, PlayerResult, PlayerResultType, PlayerState, Query, Subscription, UserRole, generateBaseMutations, generateBaseQueries, generateBaseSubscriptions };