ic-mops 0.28.0 → 0.28.2

package/dist/declarations/bench/index.d.ts

@@ -0,0 +1,50 @@
+import type {
+  ActorSubclass,
+  HttpAgentOptions,
+  ActorConfig,
+  Agent,
+} from "@dfinity/agent";
+import type { Principal } from "@dfinity/principal";
+import type { IDL } from "@dfinity/candid";
+
+import { _SERVICE } from './bench.did';
+
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const canisterId: string;
+
+export declare interface CreateActorOptions {
+  /**
+   * @see {@link Agent}
+   */
+  agent?: Agent;
+  /**
+   * @see {@link HttpAgentOptions}
+   */
+  agentOptions?: HttpAgentOptions;
+  /**
+   * @see {@link ActorConfig}
+   */
+  actorOptions?: ActorConfig;
+}
+
+/**
+ * Intializes an {@link ActorSubclass}, configured with the provided SERVICE interface of a canister.
+ * @constructs {@link ActorSubClass}
+ * @param {string | Principal} canisterId - ID of the canister the {@link Actor} will talk to
+ * @param {CreateActorOptions} options - see {@link CreateActorOptions}
+ * @param {CreateActorOptions["agent"]} options.agent - a pre-configured agent you'd like to use. Supercedes agentOptions
+ * @param {CreateActorOptions["agentOptions"]} options.agentOptions - options to set up a new agent
+ * @see {@link HttpAgentOptions}
+ * @param {CreateActorOptions["actorOptions"]} options.actorOptions - options for the Actor
+ * @see {@link ActorConfig}
+ */
+export declare const createActor: (
+  canisterId: string | Principal,
+  options?: CreateActorOptions
+) => ActorSubclass<_SERVICE>;
+
+/**
+ * Intialized Actor using default settings, ready to talk to a canister using its candid interface
+ * @constructs {@link ActorSubClass}
+ */
+export declare const bench: ActorSubclass<_SERVICE>;

package/dist/declarations/bench/index.js

@@ -0,0 +1,41 @@
+import { Actor, HttpAgent } from "@dfinity/agent";
+
+// Imports and re-exports candid interface
+import { idlFactory } from "./bench.did.js";
+export { idlFactory } from "./bench.did.js";
+
+/* CANISTER_ID is replaced by webpack based on node environment
+ * Note: canister environment variable will be standardized as
+ * process.env.CANISTER_ID_<CANISTER_NAME_UPPERCASE>
+ * beginning in dfx 0.15.0
+ */
+export const canisterId =
+  process.env.CANISTER_ID_BENCH ||
+  process.env.BENCH_CANISTER_ID;
+
+export const createActor = (canisterId, options = {}) => {
+  const agent = options.agent || new HttpAgent({ ...options.agentOptions });
+
+  if (options.agent && options.agentOptions) {
+    console.warn(
+      "Detected both agent and agentOptions passed to createActor. Ignoring agentOptions and proceeding with the provided agent."
+    );
+  }
+
+  // Fetch root key for certificate validation during development
+  if (process.env.DFX_NETWORK !== "ic") {
+    agent.fetchRootKey().catch((err) => {
+      console.warn(
+        "Unable to fetch root key. Check to ensure that your local replica is running"
+      );
+      console.error(err);
+    });
+  }
+
+  // Creates an actor with using the candid interface and the HttpAgent
+  return Actor.createActor(idlFactory, {
+    agent,
+    canisterId,
+    ...options.actorOptions,
+  });
+};

package/dist/declarations/main/main.did

@@ -41,6 +41,20 @@ type TestStats =
    passed: nat;
    passedNames: vec text;
  };
+type StreamingToken = blob;
+type StreamingStrategy = variant {
+                           Callback:
+                            record {
+                              callback: StreamingCallback;
+                              token: StreamingToken;
+                            };};
+type StreamingCallbackResponse = 
+ record {
+   body: blob;
+   token: opt StreamingToken;
+ };
+type StreamingCallback = func (StreamingToken) ->
+                          (opt StreamingCallbackResponse) query;
 type StorageStats = 
  record {
    cyclesBalance: nat;
@@ -102,6 +116,22 @@ type Result =
    err: Err;
    ok;
  };
+type Response = 
+ record {
+   body: blob;
+   headers: vec Header;
+   status_code: nat16;
+   streaming_strategy: opt StreamingStrategy;
+   upgrade: opt bool;
+ };
+type Request = 
+ record {
+   body: blob;
+   certificate_version: opt nat16;
+   headers: vec Header;
+   method: text;
+   url: text;
+ };
 type PublishingId = text;
 type PublishingErr = text;
 type PageCount = nat;
@@ -232,6 +262,11 @@ type PackageChanges =
    notes: text;
    tests: TestsChanges;
  };
+type Header = 
+ record {
+   text;
+   text;
+ };
 type FileId = text;
 type Err = text;
 type DownloadsSnapshot__1 = 
@@ -300,6 +335,7 @@ service : {
   getTotalDownloads: () -> (nat) query;
   getTotalPackages: () -> (nat) query;
   getUser: (principal) -> (opt User__1) query;
+  http_request: (Request) -> (Response) query;
   notifyInstall: (PackageName__1, PackageVersion) -> () oneway;
   notifyInstalls: (vec record {
                          PackageName__1;

package/dist/declarations/main/main.did.d.ts

@@ -23,6 +23,7 @@ export interface DownloadsSnapshot__1 {
 }
 export type Err = string;
 export type FileId = string;
+export type Header = [string, string];
 export interface PackageChanges {
   'tests' : TestsChanges,
   'deps' : Array<DepChange>,
@@ -142,6 +143,20 @@ export type PackageVersion = string;
 export type PageCount = bigint;
 export type PublishingErr = string;
 export type PublishingId = string;
+export interface Request {
+  'url' : string,
+  'method' : string,
+  'body' : Uint8Array | number[],
+  'headers' : Array<Header>,
+  'certificate_version' : [] | [number],
+}
+export interface Response {
+  'body' : Uint8Array | number[],
+  'headers' : Array<Header>,
+  'upgrade' : [] | [boolean],
+  'streaming_strategy' : [] | [StreamingStrategy],
+  'status_code' : number,
+}
 export type Result = { 'ok' : null } |
   { 'err' : Err };
 export type Result_1 = { 'ok' : PublishingId } |
@@ -168,6 +183,18 @@ export interface StorageStats {
   'cyclesBalance' : bigint,
   'memorySize' : bigint,
 }
+export type StreamingCallback = ActorMethod<
+  [StreamingToken],
+  [] | [StreamingCallbackResponse]
+>;
+export interface StreamingCallbackResponse {
+  'token' : [] | [StreamingToken],
+  'body' : Uint8Array | number[],
+}
+export type StreamingStrategy = {
+    'Callback' : { 'token' : StreamingToken, 'callback' : StreamingCallback }
+  };
+export type StreamingToken = Uint8Array | number[];
 export interface TestStats { 'passedNames' : Array<string>, 'passed' : bigint }
 export interface TestStats__1 {
   'passedNames' : Array<string>,
@@ -246,6 +273,7 @@ export interface _SERVICE {
   'getTotalDownloads' : ActorMethod<[], bigint>,
   'getTotalPackages' : ActorMethod<[], bigint>,
   'getUser' : ActorMethod<[Principal], [] | [User__1]>,
+  'http_request' : ActorMethod<[Request], Response>,
   'notifyInstall' : ActorMethod<[PackageName__1, PackageVersion], undefined>,
   'notifyInstalls' : ActorMethod<
     [Array<[PackageName__1, PackageVersion]>],

package/dist/declarations/main/main.did.js

@@ -174,6 +174,37 @@ export const idlFactory = ({ IDL }) => {
     'githubVerified' : IDL.Bool,
     'github' : IDL.Text,
   });
+  const Header = IDL.Tuple(IDL.Text, IDL.Text);
+  const Request = IDL.Record({
+    'url' : IDL.Text,
+    'method' : IDL.Text,
+    'body' : IDL.Vec(IDL.Nat8),
+    'headers' : IDL.Vec(Header),
+    'certificate_version' : IDL.Opt(IDL.Nat16),
+  });
+  const StreamingToken = IDL.Vec(IDL.Nat8);
+  const StreamingCallbackResponse = IDL.Record({
+    'token' : IDL.Opt(StreamingToken),
+    'body' : IDL.Vec(IDL.Nat8),
+  });
+  const StreamingCallback = IDL.Func(
+      [StreamingToken],
+      [IDL.Opt(StreamingCallbackResponse)],
+      ['query'],
+    );
+  const StreamingStrategy = IDL.Variant({
+    'Callback' : IDL.Record({
+      'token' : StreamingToken,
+      'callback' : StreamingCallback,
+    }),
+  });
+  const Response = IDL.Record({
+    'body' : IDL.Vec(IDL.Nat8),
+    'headers' : IDL.Vec(Header),
+    'upgrade' : IDL.Opt(IDL.Bool),
+    'streaming_strategy' : IDL.Opt(StreamingStrategy),
+    'status_code' : IDL.Nat16,
+  });
   const PageCount = IDL.Nat;
   const Result_3 = IDL.Variant({ 'ok' : IDL.Null, 'err' : IDL.Text });
   const Result_2 = IDL.Variant({ 'ok' : FileId, 'err' : Err });
@@ -270,6 +301,7 @@ export const idlFactory = ({ IDL }) => {
     'getTotalDownloads' : IDL.Func([], [IDL.Nat], ['query']),
     'getTotalPackages' : IDL.Func([], [IDL.Nat], ['query']),
     'getUser' : IDL.Func([IDL.Principal], [IDL.Opt(User__1)], ['query']),
+    'http_request' : IDL.Func([Request], [Response], ['query']),
     'notifyInstall' : IDL.Func(
         [PackageName__1, PackageVersion],
         [],

package/dist/helpers/get-dfx-version.d.ts

@@ -0,0 +1 @@
+export declare function getDfxVersion(): string;

package/dist/helpers/get-dfx-version.js

@@ -0,0 +1,9 @@
+import { execSync } from 'node:child_process';
+export function getDfxVersion() {
+    try {
+        let res = execSync('dfx --version').toString();
+        return res.trim().split('dfx ')[1] || '';
+    }
+    catch { }
+    return '';
+}

package/dist/helpers/get-moc-path.d.ts

@@ -0,0 +1 @@
+export declare function getMocPath(): string;

package/dist/helpers/get-moc-path.js

@@ -0,0 +1,11 @@
+import { execSync } from 'node:child_process';
+export function getMocPath() {
+    let mocPath = process.env.DFX_MOC_PATH;
+    if (!mocPath) {
+        mocPath = execSync('dfx cache show').toString().trim() + '/moc';
+    }
+    if (!mocPath) {
+        mocPath = 'moc';
+    }
+    return mocPath;
+}

package/dist/helpers/get-moc-version.d.ts

@@ -0,0 +1 @@
+export declare function getMocVersion(): string;

package/dist/helpers/get-moc-version.js

@@ -0,0 +1,7 @@
+import { execSync } from 'node:child_process';
+import { getMocPath } from './get-moc-path.js';
+export function getMocVersion() {
+    let mocPath = getMocPath();
+    let match = execSync(mocPath).toString().trim().match(/Motoko compiler ([^\s]+) .*/);
+    return match?.[1] || '';
+}

package/dist/notify-installs.js

@@ -1,10 +1,10 @@
-import { mainActor } from './mops.js';
+import { getDependencyType, mainActor } from './mops.js';
 import { resolvePackages } from './resolve-packages.js';
 export async function notifyInstalls(names) {
     let resolvedPackages = await resolvePackages();
     let packages = names.map(name => [name, resolvedPackages[name]]);
     if (packages.length) {
         let actor = await mainActor();
-        await actor.notifyInstalls(packages);
+        await actor.notifyInstalls(packages.filter(([_, version]) => getDependencyType(version) === 'mops'));
     }
 }

package/dist/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ic-mops",
-	"version": "0.28.0",
+	"version": "0.28.2",
 	"type": "module",
 	"bin": {
 		"mops": "dist/cli.js"

package/mops.toml

@@ -0,0 +1,7 @@
+[package]
+name = "a"
+version = "1.0.0"
+description = ""
+repository = ""
+keywords = [ ]
+license = "MIT"

package/notify-installs.ts

@@ -1,4 +1,4 @@
-import {mainActor} from './mops.js';
+import {getDependencyType, mainActor} from './mops.js';
 import {resolvePackages} from './resolve-packages.js';
 
 export async function notifyInstalls(names: string[]) {
@@ -6,6 +6,6 @@ export async function notifyInstalls(names: string[]) {
 	let packages: [string, string][] = names.map(name => [name, resolvedPackages[name] as string]);
 	if (packages.length) {
 		let actor = await mainActor();
-		await actor.notifyInstalls(packages);
+		await actor.notifyInstalls(packages.filter(([_, version]) => getDependencyType(version) === 'mops'));
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ic-mops",
-	"version": "0.28.0",
+	"version": "0.28.2",
 	"type": "module",
 	"bin": {
 		"mops": "dist/cli.js"

package/src/lib.mo

@@ -0,0 +1,15 @@
+module {
+	// This comment will not be included in the documentation
+	// Use triple slash for documentation
+
+	/// Add two natural numbers
+	///
+	/// Example:
+	/// ```motoko
+	/// assert add(1, 2) == 3;
+	/// assert add(7, 3) == 10;
+	/// ```
+	public func add(x : Nat, y : Nat) : Nat {
+		return x + y;
+	};
+};