@voxgig/sdkgen-langpack 0.0.1

package/.sdk/tm/dart/lib/utility/StructUtility.dart

@@ -0,0 +1,127 @@
+// Struct utility surface for the ProjectName SDK.
+//
+// Wraps the vendored voxgig struct port (voxgig_struct.dart) as an instance
+// whose members mirror the donor (ts) StructUtility class shape. Function
+// values are plain fields so tests and custom code can pass them around;
+// `byName` supports the string-keyed lookup the corpus test runner needs.
+
+import 'voxgig_struct.dart' as vs;
+
+export 'voxgig_struct.dart' show StructError;
+
+class StructUtility {
+  final clone = vs.clone;
+  final delprop = vs.delprop;
+  final escre = vs.escre;
+  final escurl = vs.escurl;
+  final filter = vs.filter;
+  final flatten = vs.flatten;
+  final getdef = vs.getdef;
+  final getelem = vs.getelem;
+  final getpath = vs.getpath;
+  final getprop = vs.getprop;
+  final haskey = vs.haskey;
+  final inject = vs.inject;
+  final isempty = vs.isempty;
+  final isfunc = vs.isfunc;
+  final iskey = vs.iskey;
+  final islist = vs.islist;
+  final ismap = vs.ismap;
+  final isnode = vs.isnode;
+  final items = vs.items;
+  final join = vs.join;
+  final joinurl = vs.joinurl;
+  final jsonify = vs.jsonify;
+  final keysof = vs.keysof;
+  final merge = vs.merge;
+  final pad = vs.pad;
+  final pathify = vs.pathify;
+  final select = vs.select;
+  final setpath = vs.setpath;
+  final setprop = vs.setprop;
+  final size = vs.size;
+  final strkey = vs.strkey;
+  final stringify = vs.stringify;
+  final transform = vs.transform;
+  final typify = vs.typify;
+  final typename = vs.typename;
+  final validate = vs.validate;
+
+  // The donor walk takes the apply functions positionally (before, after).
+  final walk = _walk;
+
+  // slice has an optional mutate flag in the port; expose donor arity.
+  final slice = _slice;
+
+  final SKIP = vs.SKIP;
+  final DELETE = vs.DELETE;
+
+  final T_any = vs.T_any;
+  final T_noval = vs.T_noval;
+  final T_boolean = vs.T_boolean;
+  final T_decimal = vs.T_decimal;
+  final T_integer = vs.T_integer;
+  final T_number = vs.T_number;
+  final T_string = vs.T_string;
+  final T_function = vs.T_function;
+  // The dart struct port has no symbol type; keep the donor bit slot.
+  final T_symbol = 1 << 23;
+  final T_null = vs.T_null;
+  final T_list = vs.T_list;
+  final T_map = vs.T_map;
+  final T_instance = vs.T_instance;
+  final T_scalar = vs.T_scalar;
+  final T_node = vs.T_node;
+
+  // String-keyed lookup for the corpus test runner (Dart has no dynamic
+  // property access, so subjects are resolved through this map).
+  dynamic byName(String name) => _byname[name];
+
+  late final Map<String, dynamic> _byname = {
+    'clone': clone,
+    'delprop': delprop,
+    'escre': escre,
+    'escurl': escurl,
+    'filter': filter,
+    'flatten': flatten,
+    'getdef': getdef,
+    'getelem': getelem,
+    'getpath': getpath,
+    'getprop': getprop,
+    'haskey': haskey,
+    'inject': inject,
+    'isempty': isempty,
+    'isfunc': isfunc,
+    'iskey': iskey,
+    'islist': islist,
+    'ismap': ismap,
+    'isnode': isnode,
+    'items': items,
+    'join': join,
+    'joinurl': joinurl,
+    'jsonify': jsonify,
+    'keysof': keysof,
+    'merge': merge,
+    'pad': pad,
+    'pathify': pathify,
+    'select': select,
+    'setpath': setpath,
+    'setprop': setprop,
+    'size': size,
+    'slice': slice,
+    'strkey': strkey,
+    'stringify': stringify,
+    'transform': transform,
+    'typify': typify,
+    'typename': typename,
+    'validate': validate,
+    'walk': walk,
+  };
+}
+
+dynamic _walk(dynamic val,
+        [Function? before, Function? after, dynamic maxdepth]) =>
+    vs.walk(val, before: before, after: after, maxdepth: maxdepth);
+
+dynamic _slice(dynamic val, [dynamic start, dynamic end]) =>
+    vs.slice(val, start, end);

package/.sdk/tm/dart/lib/utility/TransformRequestUtility.dart

@@ -0,0 +1,28 @@
+import 'voxgig_struct.dart' as vs;
+
+/* Convert entity data or match query into a structure suitable for use as
+ * request data.
+ *
+ * The operation (op) property `reqform` is used to perform the data
+ * preparation.
+ */
+dynamic transformRequest(dynamic ctx) {
+  final spec = ctx.spec;
+  final utility = ctx.utility;
+  final point = ctx.point;
+
+  if (null != spec) {
+    spec.step = 'reqform';
+  }
+
+  try {
+    final reqform = vs.getprop(point.transform, 'req');
+    final reqdata = vs.isfunc(reqform)
+        ? reqform(ctx)
+        : vs.transform({'reqdata': ctx.reqdata}, reqform);
+
+    return reqdata;
+  } catch (err) {
+    return utility.makeError(ctx, err);
+  }
+}

package/.sdk/tm/dart/lib/utility/TransformResponseUtility.dart

@@ -0,0 +1,44 @@
+import 'voxgig_struct.dart' as vs;
+
+/* Convert data from response into a structure suitable for use as entity
+ * data.
+ *
+ * The operation (op) property `resform` is used to perform the data
+ * extraction.
+ */
+dynamic transformResponse(dynamic ctx) {
+  final spec = ctx.spec;
+  final result = ctx.result;
+  final utility = ctx.utility;
+  final point = ctx.point;
+
+  if (null != spec) {
+    spec.step = 'resform';
+  }
+
+  if (null == result || true != result.ok) {
+    return null;
+  }
+
+  try {
+    final resform = vs.getprop(point.transform, 'res');
+
+    // The transform store is the result viewed as a node.
+    final store = {
+      'ok': result.ok,
+      'status': result.status,
+      'statusText': result.statusText,
+      'headers': result.headers,
+      'body': result.body,
+      'resdata': result.resdata,
+      'resmatch': result.resmatch,
+    };
+
+    final resdata =
+        vs.isfunc(resform) ? resform(ctx) : vs.transform(store, resform);
+    result.resdata = resdata;
+    return resdata;
+  } catch (err) {
+    return utility.makeError(ctx, err);
+  }
+}

package/.sdk/tm/dart/lib/utility/Utility.dart

@@ -0,0 +1,239 @@
+import 'CleanUtility.dart' as u;
+import 'DoneUtility.dart' as u;
+import 'MakeErrorUtility.dart' as u;
+import 'FeatureAddUtility.dart' as u;
+import 'FeatureHookUtility.dart' as u;
+import 'FeatureInitUtility.dart' as u;
+import 'FetcherUtility.dart' as u;
+import 'MakeFetchDefUtility.dart' as u;
+import 'MakeContextUtility.dart' as u;
+import 'MakeOptionsUtility.dart' as u;
+import 'MakeRequestUtility.dart' as u;
+import 'MakeResponseUtility.dart' as u;
+import 'MakeResultUtility.dart' as u;
+import 'MakePointUtility.dart' as u;
+import 'MakeSpecUtility.dart' as u;
+import 'MakeUrlUtility.dart' as u;
+import 'ParamUtility.dart' as u;
+import 'PrepareAuthUtility.dart' as u;
+import 'PrepareBodyUtility.dart' as u;
+import 'PrepareHeadersUtility.dart' as u;
+import 'PrepareMethodUtility.dart' as u;
+import 'PrepareParamsUtility.dart' as u;
+import 'PreparePathUtility.dart' as u;
+import 'PrepareQueryUtility.dart' as u;
+import 'ResultBasicUtility.dart' as u;
+import 'ResultBodyUtility.dart' as u;
+import 'ResultHeadersUtility.dart' as u;
+import 'TransformRequestUtility.dart' as u;
+import 'TransformResponseUtility.dart' as u;
+
+import 'GraphqlUtility.dart' as u;
+import 'StructUtility.dart';
+
+class Utility {
+  dynamic clean = u.clean;
+  dynamic done = u.done;
+  dynamic makeError = u.makeError;
+  dynamic featureAdd = u.featureAdd;
+  dynamic featureHook = u.featureHook;
+  dynamic featureInit = u.featureInit;
+  dynamic fetcher = u.fetcher;
+  dynamic makeFetchDef = u.makeFetchDef;
+  dynamic makeContext = u.makeContext;
+  dynamic makeOptions = u.makeOptions;
+  dynamic makeRequest = u.makeRequest;
+  dynamic makeResponse = u.makeResponse;
+  dynamic makeResult = u.makeResult;
+  dynamic makePoint = u.makePoint;
+  dynamic makeSpec = u.makeSpec;
+  dynamic makeUrl = u.makeUrl;
+  dynamic param = u.param;
+  dynamic prepareAuth = u.prepareAuth;
+  dynamic prepareBody = u.prepareBody;
+  dynamic prepareHeaders = u.prepareHeaders;
+  dynamic prepareMethod = u.prepareMethod;
+  dynamic prepareParams = u.prepareParams;
+  dynamic preparePath = u.preparePath;
+  dynamic prepareQuery = u.prepareQuery;
+  dynamic graphqlBody = u.graphqlBody;
+  dynamic graphqlErrors = u.graphqlErrors;
+  dynamic resultBasic = u.resultBasic;
+  dynamic resultBody = u.resultBody;
+  dynamic resultHeaders = u.resultHeaders;
+  dynamic transformRequest = u.transformRequest;
+  dynamic transformResponse = u.transformResponse;
+
+  final StructUtility struct = StructUtility();
+
+  // Custom utilities injected via options.utility that do not override a
+  // standard member (see makeOptions).
+  final Map<String, dynamic> custom = {};
+
+  // Assign a utility function by name; unknown names land in `custom`.
+  void setUtility(String name, dynamic fn) {
+    switch (name) {
+      case 'clean':
+        clean = fn;
+        break;
+      case 'done':
+        done = fn;
+        break;
+      case 'makeError':
+        makeError = fn;
+        break;
+      case 'featureAdd':
+        featureAdd = fn;
+        break;
+      case 'featureHook':
+        featureHook = fn;
+        break;
+      case 'featureInit':
+        featureInit = fn;
+        break;
+      case 'fetcher':
+        fetcher = fn;
+        break;
+      case 'makeFetchDef':
+        makeFetchDef = fn;
+        break;
+      case 'makeContext':
+        makeContext = fn;
+        break;
+      case 'makeOptions':
+        makeOptions = fn;
+        break;
+      case 'makeRequest':
+        makeRequest = fn;
+        break;
+      case 'makeResponse':
+        makeResponse = fn;
+        break;
+      case 'makeResult':
+        makeResult = fn;
+        break;
+      case 'makePoint':
+        makePoint = fn;
+        break;
+      case 'makeSpec':
+        makeSpec = fn;
+        break;
+      case 'makeUrl':
+        makeUrl = fn;
+        break;
+      case 'param':
+        param = fn;
+        break;
+      case 'prepareAuth':
+        prepareAuth = fn;
+        break;
+      case 'prepareBody':
+        prepareBody = fn;
+        break;
+      case 'prepareHeaders':
+        prepareHeaders = fn;
+        break;
+      case 'prepareMethod':
+        prepareMethod = fn;
+        break;
+      case 'prepareParams':
+        prepareParams = fn;
+        break;
+      case 'preparePath':
+        preparePath = fn;
+        break;
+      case 'graphqlBody':
+        graphqlBody = fn;
+        break;
+      case 'graphqlErrors':
+        graphqlErrors = fn;
+        break;
+      case 'prepareQuery':
+        prepareQuery = fn;
+        break;
+      case 'resultBasic':
+        resultBasic = fn;
+        break;
+      case 'resultBody':
+        resultBody = fn;
+        break;
+      case 'resultHeaders':
+        resultHeaders = fn;
+        break;
+      case 'transformRequest':
+        transformRequest = fn;
+        break;
+      case 'transformResponse':
+        transformResponse = fn;
+        break;
+      default:
+        custom[name] = fn;
+    }
+  }
+
+  // String-keyed lookup (corpus test runner, custom utilities).
+  dynamic byName(String name) {
+    switch (name) {
+      case 'clean':
+        return clean;
+      case 'done':
+        return done;
+      case 'makeError':
+        return makeError;
+      case 'featureAdd':
+        return featureAdd;
+      case 'featureHook':
+        return featureHook;
+      case 'featureInit':
+        return featureInit;
+      case 'fetcher':
+        return fetcher;
+      case 'makeFetchDef':
+        return makeFetchDef;
+      case 'makeContext':
+        return makeContext;
+      case 'makeOptions':
+        return makeOptions;
+      case 'makeRequest':
+        return makeRequest;
+      case 'makeResponse':
+        return makeResponse;
+      case 'makeResult':
+        return makeResult;
+      case 'makePoint':
+        return makePoint;
+      case 'makeSpec':
+        return makeSpec;
+      case 'makeUrl':
+        return makeUrl;
+      case 'param':
+        return param;
+      case 'prepareAuth':
+        return prepareAuth;
+      case 'prepareBody':
+        return prepareBody;
+      case 'prepareHeaders':
+        return prepareHeaders;
+      case 'prepareMethod':
+        return prepareMethod;
+      case 'prepareParams':
+        return prepareParams;
+      case 'preparePath':
+        return preparePath;
+      case 'prepareQuery':
+        return prepareQuery;
+      case 'resultBasic':
+        return resultBasic;
+      case 'resultBody':
+        return resultBody;
+      case 'resultHeaders':
+        return resultHeaders;
+      case 'transformRequest':
+        return transformRequest;
+      case 'transformResponse':
+        return transformResponse;
+      default:
+        return custom[name];
+    }
+  }
+}