@asagiri-design/labels-config 0.2.2

package/dist/index.js

@@ -0,0 +1,306 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  LabelManager: () => LabelManager,
+  checkDuplicateColors: () => checkDuplicateColors,
+  checkDuplicateNames: () => checkDuplicateNames,
+  default: () => index_default,
+  flattenLabels: () => flattenLabels,
+  isCategorized: () => isCategorized,
+  labelCategorySchema: () => labelCategorySchema,
+  labelConfigSchema: () => labelConfigSchema,
+  labelRegistrySchema: () => labelRegistrySchema,
+  validateLabel: () => validateLabel,
+  validateLabels: () => validateLabels,
+  validateRegistry: () => validateRegistry,
+  validateWithDetails: () => validateWithDetails,
+  version: () => version
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+function isCategorized(labels) {
+  return Array.isArray(labels) && labels.length > 0 && "category" in labels[0] && "labels" in labels[0];
+}
+function flattenLabels(labels) {
+  if (isCategorized(labels)) {
+    return labels.flatMap((cat) => cat.labels);
+  }
+  return labels;
+}
+
+// src/validation.ts
+var import_zod = require("zod");
+
+// src/utils/color.ts
+function normalizeHexColor(input) {
+  const color = input.toLowerCase();
+  if (color.length === 3) {
+    return color.split("").map((c) => c + c).join("");
+  }
+  return color;
+}
+
+// src/validation.ts
+var hexColorSchema = import_zod.z.string().regex(/^[0-9a-fA-F]{6}$|^[0-9a-fA-F]{3}$/, "Invalid hex color format").transform((color) => normalizeHexColor(color));
+var labelConfigSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1, "Label name is required").max(50, "Label name must be 50 characters or less").regex(
+    /^[a-zA-Z0-9\-\s\/\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FFF]+$/,
+    "Label name contains invalid characters"
+  ),
+  color: hexColorSchema,
+  description: import_zod.z.string().min(1, "Description is required").max(200, "Description must be 200 characters or less")
+});
+var labelCategorySchema = import_zod.z.object({
+  category: import_zod.z.string().min(1, "Category name is required").max(50, "Category name must be 50 characters or less"),
+  labels: import_zod.z.array(labelConfigSchema)
+});
+var labelRegistrySchema = import_zod.z.object({
+  version: import_zod.z.string(),
+  timestamp: import_zod.z.string().datetime().optional(),
+  labels: import_zod.z.union([
+    import_zod.z.array(labelConfigSchema),
+    import_zod.z.array(labelCategorySchema)
+  ]),
+  metadata: import_zod.z.record(import_zod.z.unknown()).optional()
+});
+function validateLabel(label) {
+  return labelConfigSchema.parse(label);
+}
+function validateLabels(labels) {
+  const schema = import_zod.z.array(labelConfigSchema);
+  return schema.parse(labels);
+}
+function validateRegistry(registry) {
+  return labelRegistrySchema.parse(registry);
+}
+function findDuplicateStrings(values) {
+  const seen = /* @__PURE__ */ new Map();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const count = seen.get(value) || 0;
+    seen.set(value, count + 1);
+    if (count === 1) {
+      duplicates.add(value);
+    }
+  }
+  return Array.from(duplicates);
+}
+function checkDuplicateNames(labels) {
+  const names = labels.map((label) => label.name);
+  return findDuplicateStrings(names);
+}
+function checkDuplicateColors(labels) {
+  const colors = labels.map((label) => normalizeHexColor(label.color));
+  return findDuplicateStrings(colors);
+}
+function validateWithDetails(labels) {
+  try {
+    const parsed = validateLabels(labels);
+    const duplicateNames = checkDuplicateNames(parsed);
+    const duplicateColors = checkDuplicateColors(parsed);
+    return {
+      valid: duplicateNames.length === 0 && duplicateColors.length === 0,
+      labels: parsed,
+      errors: {
+        duplicateNames,
+        duplicateColors
+      }
+    };
+  } catch (error) {
+    if (error instanceof import_zod.z.ZodError) {
+      return {
+        valid: false,
+        labels: [],
+        errors: {
+          validationErrors: error.errors
+        }
+      };
+    }
+    throw error;
+  }
+}
+
+// src/manager.ts
+var LabelManager = class {
+  constructor(options = {}) {
+    __publicField(this, "labels", /* @__PURE__ */ new Map());
+    __publicField(this, "strict", false);
+    this.strict = options.strict ?? false;
+    if (options.labels) {
+      this.loadLabels(options.labels);
+    }
+  }
+  /**
+   * Load labels from array
+   */
+  loadLabels(labels) {
+    const validation = validateWithDetails(labels);
+    if (!validation.valid && this.strict) {
+      throw new Error(`Label validation failed: ${JSON.stringify(validation.errors)}`);
+    }
+    this.labels.clear();
+    validation.labels.forEach((label) => {
+      this.labels.set(label.name.toLowerCase(), label);
+    });
+  }
+  /**
+   * Load labels from registry object
+   */
+  loadRegistry(registry) {
+    const labels = flattenLabels(registry.labels);
+    this.loadLabels(labels);
+  }
+  /**
+   * Add a single label
+   */
+  addLabel(label) {
+    const validation = validateLabels([label]);
+    const newLabel = validation[0];
+    if (this.labels.has(newLabel.name.toLowerCase())) {
+      throw new Error(`Label "${newLabel.name}" already exists`);
+    }
+    this.labels.set(newLabel.name.toLowerCase(), newLabel);
+  }
+  /**
+   * Update an existing label
+   */
+  updateLabel(name, updates) {
+    const key = name.toLowerCase();
+    const existing = this.labels.get(key);
+    if (!existing) {
+      throw new Error(`Label "${name}" not found`);
+    }
+    const updated = { ...existing, ...updates };
+    const validation = validateLabels([updated]);
+    this.labels.set(key, validation[0]);
+  }
+  /**
+   * Remove a label
+   */
+  removeLabel(name) {
+    this.labels.delete(name.toLowerCase());
+  }
+  /**
+   * Get a label by name
+   */
+  getLabel(name) {
+    return this.labels.get(name.toLowerCase());
+  }
+  /**
+   * Check if label exists
+   */
+  hasLabel(name) {
+    return this.labels.has(name.toLowerCase());
+  }
+  /**
+   * Get all labels
+   */
+  getAllLabels() {
+    return Array.from(this.labels.values());
+  }
+  /**
+   * Get labels count
+   */
+  count() {
+    return this.labels.size;
+  }
+  /**
+   * Export labels as array
+   */
+  export() {
+    return this.getAllLabels();
+  }
+  /**
+   * Export as registry object
+   */
+  exportRegistry(version2 = "1.0.0", metadata) {
+    return {
+      version: version2,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      labels: this.getAllLabels(),
+      metadata
+    };
+  }
+  /**
+   * Search labels by name or description
+   */
+  search(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.getAllLabels().filter(
+      (label) => label.name.toLowerCase().includes(lowerQuery) || label.description.toLowerCase().includes(lowerQuery)
+    );
+  }
+  /**
+   * Find labels by color
+   */
+  findByColor(color) {
+    const normalizedColor = color.toLowerCase();
+    return this.getAllLabels().filter((label) => label.color.toLowerCase() === normalizedColor);
+  }
+  /**
+   * Clear all labels
+   */
+  clear() {
+    this.labels.clear();
+  }
+  /**
+   * Validate current state
+   */
+  validate() {
+    const labels = this.getAllLabels();
+    const duplicates = checkDuplicateNames(labels);
+    return {
+      valid: duplicates.length === 0,
+      duplicates
+    };
+  }
+};
+
+// src/version.ts
+var version = "0.2.2";
+
+// src/index.ts
+var index_default = {
+  LabelManager,
+  validateLabels,
+  validateWithDetails,
+  version
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LabelManager,
+  checkDuplicateColors,
+  checkDuplicateNames,
+  flattenLabels,
+  isCategorized,
+  labelCategorySchema,
+  labelConfigSchema,
+  labelRegistrySchema,
+  validateLabel,
+  validateLabels,
+  validateRegistry,
+  validateWithDetails,
+  version
+});

package/dist/index.mjs

@@ -0,0 +1,44 @@
+import {
+  LabelManager,
+  flattenLabels,
+  isCategorized
+} from "./chunk-DSI7SDAM.mjs";
+import {
+  checkDuplicateColors,
+  checkDuplicateNames,
+  labelCategorySchema,
+  labelConfigSchema,
+  labelRegistrySchema,
+  validateLabel,
+  validateLabels,
+  validateRegistry,
+  validateWithDetails
+} from "./chunk-VU2JB66N.mjs";
+import "./chunk-QZ7TP4HQ.mjs";
+
+// src/version.ts
+var version = "0.2.2";
+
+// src/index.ts
+var index_default = {
+  LabelManager,
+  validateLabels,
+  validateWithDetails,
+  version
+};
+export {
+  LabelManager,
+  checkDuplicateColors,
+  checkDuplicateNames,
+  index_default as default,
+  flattenLabels,
+  isCategorized,
+  labelCategorySchema,
+  labelConfigSchema,
+  labelRegistrySchema,
+  validateLabel,
+  validateLabels,
+  validateRegistry,
+  validateWithDetails,
+  version
+};

package/dist/types-CkwsO1Iu.d.mts

@@ -0,0 +1,50 @@
+/**
+ * Label Configuration Types
+ * Defines the structure and validation rules for labels
+ */
+type HexColor = string & {
+    readonly __brand: 'HexColor';
+};
+interface LabelConfig {
+    /**
+     * Unique identifier for the label
+     * Used in GitHub as the label name
+     */
+    name: string;
+    /**
+     * Hex color code (without # prefix)
+     * Examples: 'ffb300', '008672', 'ff0000'
+     */
+    color: HexColor;
+    /**
+     * Human-readable description
+     * Displayed in GitHub and UI components
+     */
+    description: string;
+}
+interface LabelCategory {
+    /** Category name for grouping related labels */
+    category: string;
+    /** Labels in this category */
+    labels: LabelConfig[];
+}
+interface LabelRegistry {
+    /** Version of the label configuration */
+    version: string;
+    /** Timestamp of last update */
+    timestamp?: string;
+    /** All labels, optionally grouped by category */
+    labels: LabelConfig[] | LabelCategory[];
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Type guard for checking if labels are categorized
+ */
+declare function isCategorized(labels: LabelConfig[] | LabelCategory[]): labels is LabelCategory[];
+/**
+ * Flatten categorized labels to a flat array
+ */
+declare function flattenLabels(labels: LabelConfig[] | LabelCategory[]): LabelConfig[];
+
+export { type HexColor as H, type LabelConfig as L, type LabelRegistry as a, type LabelCategory as b, flattenLabels as f, isCategorized as i };

package/dist/types-CkwsO1Iu.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Label Configuration Types
+ * Defines the structure and validation rules for labels
+ */
+type HexColor = string & {
+    readonly __brand: 'HexColor';
+};
+interface LabelConfig {
+    /**
+     * Unique identifier for the label
+     * Used in GitHub as the label name
+     */
+    name: string;
+    /**
+     * Hex color code (without # prefix)
+     * Examples: 'ffb300', '008672', 'ff0000'
+     */
+    color: HexColor;
+    /**
+     * Human-readable description
+     * Displayed in GitHub and UI components
+     */
+    description: string;
+}
+interface LabelCategory {
+    /** Category name for grouping related labels */
+    category: string;
+    /** Labels in this category */
+    labels: LabelConfig[];
+}
+interface LabelRegistry {
+    /** Version of the label configuration */
+    version: string;
+    /** Timestamp of last update */
+    timestamp?: string;
+    /** All labels, optionally grouped by category */
+    labels: LabelConfig[] | LabelCategory[];
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Type guard for checking if labels are categorized
+ */
+declare function isCategorized(labels: LabelConfig[] | LabelCategory[]): labels is LabelCategory[];
+/**
+ * Flatten categorized labels to a flat array
+ */
+declare function flattenLabels(labels: LabelConfig[] | LabelCategory[]): LabelConfig[];
+
+export { type HexColor as H, type LabelConfig as L, type LabelRegistry as a, type LabelCategory as b, flattenLabels as f, isCategorized as i };