@neutron.co.id/operasional-interfaces 1.14.0 → 1.14.2

package/build/nuxt.mjs

@@ -0,0 +1,250 @@
+import { createResolver, addComponent, useNuxt, addImports, defineNuxtModule, addPlugin } from '@nuxt/kit';
+import { Build, Style } from '@neon.id/nuxt';
+import { OfficeInterfaces } from '@neon.id/context/helpers';
+
+function setupBuild(config) {
+  const { resolve } = createResolver(import.meta.url);
+  Build.config({
+    transpile: [resolve("../runtime")],
+    dedupe: [],
+    alias: {},
+    include: [],
+    exclude: []
+  });
+}
+
+const config = OfficeInterfaces.define({
+  components: {
+    common: [],
+    models: {
+      personalia: [
+        // Attendance
+        "AttendanceCollection",
+        "AttendanceSingle",
+        "AttendanceStaff",
+        "AttendanceManager",
+        "AttendanceSupervisor",
+        // Check In
+        "CheckInCollection",
+        "CheckInSingle",
+        "CheckInAccess",
+        "CheckInExternal",
+        "CheckInPresenceCollection",
+        "CheckInScanError",
+        "CheckInScanner",
+        "CheckInScanSuccess",
+        "CheckInSupervisor",
+        // Plan
+        "PlanCollection",
+        "PlanSingle",
+        "PlanStaff",
+        // Plan
+        "PlanTypeCollection",
+        "PlanTypeSingle",
+        // Progress
+        "ProgressCollection",
+        "ProgressSingle",
+        "ProgressNote",
+        "ProgressTomorrow",
+        "ProgressYesterday",
+        // Progress Access
+        "ProgressAccessCollection",
+        "ProgressAccessSingle",
+        "ProgressAccessSupervisor",
+        // Responsibility
+        "ResponsibilityCollection",
+        "ResponsibilitySingle",
+        "ResponsibilityStaff",
+        "ResponsibilitySupervisor",
+        // Responsibility Type
+        "ResponsibilityTypeCollection",
+        "ResponsibilityTypeSingle",
+        // Situation
+        "SituationCollection",
+        "SituationSingle",
+        "SituationSupportive",
+        "SituationWork",
+        // Situation Type
+        "SituationTypeCollection",
+        "SituationTypeSingle",
+        // Staff
+        "StaffCollection",
+        "StaffSingle",
+        "StaffAccess",
+        "StaffIdentity",
+        "StaffOperasional",
+        // Submission
+        "SubmissionCollection",
+        "SubmissionSingle",
+        "SubmissionAudit",
+        "SubmissionDecision",
+        "SubmissionFollowUp",
+        "SubmissionStaff",
+        "SubmissionSupervisor",
+        "SubmissionWaitingDecision",
+        // Submission Type
+        "SubmissionTypeCollection",
+        "SubmissionTypeSingle",
+        // Target
+        "TargetCollection",
+        "TargetSingle",
+        "TargetBranch",
+        // Task
+        "TaskCollection",
+        "TaskSingle",
+        "TaskWork"
+      ]
+    },
+    features: {}
+  },
+  imports: {
+    common: [
+      "withOperasional",
+      "useAttendanceStore",
+      "useOperasionalStore",
+      "NOperasional",
+      "useOperasional"
+    ],
+    models: {},
+    features: {}
+  }
+});
+
+async function setupComponents(config$1) {
+  const _office = await add$1("office", config.getComponents(config$1.office));
+  return [..._office];
+}
+async function add$1(key, names) {
+  for (const name of names) {
+    await addComponent({
+      name,
+      export: name,
+      filePath: `@neutron.co.id/operasional-interfaces/${key}`,
+      global: true
+    });
+  }
+  return names;
+}
+
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
+}
+
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isPlainObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isPlainObject(value) && isPlainObject(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
+  );
+}
+const defu = createDefu();
+
+function setupConfig(options) {
+  const nuxt = useNuxt();
+  const env = options?.env || process.env.APP_ENVIRONMENT || "test";
+  const config = defu(options, {
+    env,
+    isDebug: false,
+    isProd: env === "prod",
+    mode: options.mode || "office",
+    office: {}
+  });
+  const key = "neu:operasional:interfaces";
+  nuxt.options.runtimeConfig[key] = config;
+  nuxt.options.runtimeConfig.public[key] = config;
+  nuxt.options.runtimeConfig.operasional = config;
+  nuxt.options.runtimeConfig.public.operasional = config;
+  return config;
+}
+
+function setupImports(config$1) {
+  const _office = add("office", config.getImports(config$1.office));
+  return [..._office];
+}
+function add(key, names) {
+  addImports(
+    [...names].map((name) => ({
+      from: `@neutron.co.id/operasional-interfaces/${key}`,
+      name,
+      as: name
+    }))
+  );
+  return names;
+}
+
+function setupStyles(config) {
+  if (config.office) {
+    Style.config({
+      content: ["@neutron.co.id/operasional-interfaces/office"],
+      css: []
+    });
+  }
+}
+
+const nuxt = defineNuxtModule({
+  meta: {
+    name: "@neutron.co.id/operasional-interfaces",
+    configKey: "neu:operasional:interfaces",
+    compatibility: { nuxt: "^3.0.0" }
+  },
+  defaults: {
+    env: process.env.APP_ENVIRONMENT,
+    isDebug: false,
+    mode: "office"
+  },
+  hooks: {},
+  async setup(options) {
+    const { resolve } = createResolver(import.meta.url);
+    const config = setupConfig(options);
+    setupBuild();
+    setupStyles(config);
+    setupImports(config);
+    await setupComponents(config);
+    addPlugin(resolve("./runtime/plugins/plugin.operasional"));
+  }
+});
+
+export { nuxt as default };

package/build/runtime/plugins/plugin.operasional.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/build/runtime/plugins/plugin.operasional.js

@@ -0,0 +1,7 @@
+import { defineNuxtPlugin } from "#app";
+export default defineNuxtPlugin({
+  name: "neu:operasional",
+  async setup() {
+    console.log("plugin:neu:operasional");
+  }
+});

package/build/types.d.mts

@@ -0,0 +1,19 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module, ModuleHooks, ModuleRuntimeConfig, ModulePublicRuntimeConfig } from './nuxt.js'
+
+declare module '@nuxt/schema' {
+  interface NuxtHooks extends ModuleHooks {}
+  interface RuntimeConfig extends ModuleRuntimeConfig {}
+  interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
+}
+
+declare module 'nuxt/schema' {
+  interface NuxtHooks extends ModuleHooks {}
+  interface RuntimeConfig extends ModuleRuntimeConfig {}
+  interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
+}
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { type ModuleHooks, type ModulePublicRuntimeConfig, type ModuleRuntimeConfig, default } from './nuxt.js'

package/build/types.d.ts

@@ -0,0 +1,19 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module, ModuleHooks, ModuleRuntimeConfig, ModulePublicRuntimeConfig } from './nuxt'
+
+declare module '@nuxt/schema' {
+  interface NuxtHooks extends ModuleHooks {}
+  interface RuntimeConfig extends ModuleRuntimeConfig {}
+  interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
+}
+
+declare module 'nuxt/schema' {
+  interface NuxtHooks extends ModuleHooks {}
+  interface RuntimeConfig extends ModuleRuntimeConfig {}
+  interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
+}
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { type ModuleHooks, type ModulePublicRuntimeConfig, type ModuleRuntimeConfig, default } from './nuxt'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neutron.co.id/operasional-interfaces",
-  "version": "1.14.0",
+  "version": "1.14.2",
   "description": "Interface library of Neutron Operasional.",
   "sideEffects": [
     "*.css"
@@ -156,5 +156,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "build": 154
+  "build": 156
 }