@wp-typia/project-tools 0.21.0 → 0.22.0

package/dist/runtime/cli-add-workspace-admin-view.js

@@ -8,14 +8,22 @@ import { PROJECT_TOOLS_PACKAGE_ROOT } from "./template-registry.js";
 import { toPascalCase, toTitleCase } from "./string-case.js";
 import { findPhpFunctionRange, hasPhpFunctionDefinition, quotePhpString, replacePhpFunctionDefinition, } from "./php-utils.js";
 import { assertAdminViewDoesNotExist, assertValidGeneratedSlug, getWorkspaceBootstrapPath, normalizeBlockSlug, patchFile, quoteTsString, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
-const ADMIN_VIEW_SOURCE_KIND = "rest-resource";
+import { CLI_DIAGNOSTIC_CODES, createCliDiagnosticCodeError, } from "./cli-diagnostics.js";
+import { DEFAULT_WORDPRESS_DATAVIEWS_VERSION, DEFAULT_WORDPRESS_CORE_DATA_VERSION, DEFAULT_WORDPRESS_DATA_VERSION, DEFAULT_WP_TYPIA_DATAVIEWS_VERSION, } from "./package-versions.js";
+const ADMIN_VIEW_REST_SOURCE_KIND = "rest-resource";
+const ADMIN_VIEW_CORE_DATA_SOURCE_KIND = "core-data";
+const ADMIN_VIEW_CORE_DATA_ENTITY_KIND_IDS = ["postType", "taxonomy"];
+const ADMIN_VIEW_CORE_DATA_ENTITY_SEGMENT_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/u;
+const ADMIN_VIEW_CORE_DATA_ENTITY_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]*$/u;
+const ADMIN_VIEW_SOURCE_USAGE = "wp-typia add admin-view <name> --source <rest-resource:slug|core-data:kind/name>";
 const ADMIN_VIEWS_SCRIPT = "build/admin-views/index.js";
 const ADMIN_VIEWS_ASSET = "build/admin-views/index.asset.php";
 const ADMIN_VIEWS_STYLE = "build/admin-views/style-index.css";
 const ADMIN_VIEWS_STYLE_RTL = "build/admin-views/style-index-rtl.css";
 const ADMIN_VIEWS_PHP_GLOB = "/inc/admin-views/*.php";
-const DEFAULT_WP_TYPIA_DATAVIEWS_VERSION = "^0.1.0";
-const DEFAULT_WORDPRESS_DATAVIEWS_VERSION = "^14.1.0";
+const ADMIN_VIEW_ALLOW_UNPUBLISHED_DATAVIEWS_ENV = "WP_TYPIA_ALLOW_UNPUBLISHED_DATAVIEWS";
+// Lift this gate in the same release that publishes @wp-typia/dataviews.
+const ADMIN_VIEW_PUBLIC_INSTALLS_ENABLED = false;
 const require = createRequire(import.meta.url);
 function toCamelCase(input) {
     const pascalCase = toPascalCase(input);
@@ -28,15 +36,26 @@ function normalizeVersionRange(value, fallback) {
     }
     return /^[~^<>=]/u.test(trimmed) ? trimmed : `^${trimmed}`;
 }
-function readPackageManifestVersion(packageJsonPath) {
+function readPackageManifest(packageJsonPath) {
     try {
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-        return packageJson.version;
+        return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
     }
     catch {
         return undefined;
     }
 }
+function readPackageManifestVersion(packageJsonPath) {
+    return readPackageManifest(packageJsonPath)?.version;
+}
+function isAdminViewUnpublishedDataViewsOverrideEnabled() {
+    return process.env[ADMIN_VIEW_ALLOW_UNPUBLISHED_DATAVIEWS_ENV]?.trim() === "1";
+}
+function assertAdminViewPackageAvailability() {
+    if (isAdminViewUnpublishedDataViewsOverrideEnabled() || ADMIN_VIEW_PUBLIC_INSTALLS_ENABLED) {
+        return;
+    }
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, "`wp-typia add admin-view` is temporarily unavailable because `@wp-typia/dataviews` is not published to npm for public installs yet.");
+}
 function detectJsonIndent(source) {
     const indentMatch = /\n([ \t]+)"/u.exec(source);
     return indentMatch?.[1] ?? 2;
@@ -62,22 +81,77 @@ function getAdminViewRelativeModuleSpecifier(adminViewSlug, workspaceFile) {
     const relativeModulePath = path.posix.relative(adminViewDir, modulePath);
     return relativeModulePath.startsWith(".") ? relativeModulePath : `./${relativeModulePath}`;
 }
+function isAdminViewCoreDataSource(source) {
+    return source?.kind === ADMIN_VIEW_CORE_DATA_SOURCE_KIND;
+}
+function isAdminViewRestResourceSource(source) {
+    return source?.kind === ADMIN_VIEW_REST_SOURCE_KIND;
+}
+function assertValidCoreDataEntitySegment(label, value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new Error(`${label} is required. Use \`${ADMIN_VIEW_SOURCE_USAGE}\`.`);
+    }
+    if (!ADMIN_VIEW_CORE_DATA_ENTITY_SEGMENT_PATTERN.test(trimmed)) {
+        throw new Error(`${label} must start with a letter and contain only letters, numbers, underscores, or hyphens.`);
+    }
+    return trimmed;
+}
+function assertValidCoreDataEntityName(value) {
+    const normalized = value.trim();
+    if (!normalized) {
+        throw new Error(`Admin view source entity name is required. Use \`${ADMIN_VIEW_SOURCE_USAGE}\`.`);
+    }
+    if (!ADMIN_VIEW_CORE_DATA_ENTITY_NAME_PATTERN.test(normalized)) {
+        throw new Error("Admin view source entity name must start with a lowercase letter or number and contain only lowercase letters, numbers, underscores, or hyphens.");
+    }
+    return normalized;
+}
+function assertValidCoreDataEntityKind(value) {
+    const normalized = assertValidCoreDataEntitySegment("Admin view source entity kind", value);
+    if (!ADMIN_VIEW_CORE_DATA_ENTITY_KIND_IDS.includes(normalized)) {
+        throw new Error(`Admin view core-data sources currently support only: ${ADMIN_VIEW_CORE_DATA_ENTITY_KIND_IDS.join(", ")}.`);
+    }
+    return normalized;
+}
+function formatAdminViewSourceLocator(source) {
+    if (isAdminViewCoreDataSource(source)) {
+        return `${source.kind}:${source.entityKind}/${source.entityName}`;
+    }
+    return `${source.kind}:${source.slug}`;
+}
 function parseAdminViewSource(source) {
     const trimmed = source?.trim();
     if (!trimmed) {
         return undefined;
     }
-    const [kind, slug, extra] = trimmed.split(":");
-    if (kind !== ADMIN_VIEW_SOURCE_KIND || !slug || extra !== undefined) {
-        throw new Error("Admin view source must use `rest-resource:<slug>` for now.");
+    const separatorIndex = trimmed.indexOf(":");
+    const kind = separatorIndex === -1 ? trimmed : trimmed.slice(0, separatorIndex);
+    const locator = separatorIndex === -1 ? "" : trimmed.slice(separatorIndex + 1);
+    if (!locator) {
+        throw new Error("Admin view source must use `rest-resource:<slug>` or `core-data:<kind>/<name>`.");
     }
-    return {
-        kind,
-        slug: assertValidGeneratedSlug("Admin view source slug", normalizeBlockSlug(slug), "wp-typia add admin-view <name> --source rest-resource:<slug>"),
-    };
+    if (kind === ADMIN_VIEW_REST_SOURCE_KIND) {
+        return {
+            kind,
+            slug: assertValidGeneratedSlug("Admin view source slug", locator, ADMIN_VIEW_SOURCE_USAGE),
+        };
+    }
+    if (kind === ADMIN_VIEW_CORE_DATA_SOURCE_KIND) {
+        const [entityKind, entityName, extra] = locator.split("/");
+        if (!entityKind || !entityName || extra !== undefined) {
+            throw new Error("Admin view core-data sources must use `core-data:<kind>/<name>`, for example `core-data:postType/post`.");
+        }
+        return {
+            entityKind: assertValidCoreDataEntityKind(entityKind),
+            entityName: assertValidCoreDataEntityName(entityName),
+            kind,
+        };
+    }
+    throw new Error("Admin view source must use `rest-resource:<slug>` or `core-data:<kind>/<name>`.");
 }
 function resolveRestResourceSource(restResources, source) {
-    if (!source) {
+    if (!isAdminViewRestResourceSource(source)) {
         return undefined;
     }
     const restResource = restResources.find((entry) => entry.slug === source.slug);
@@ -97,7 +171,9 @@ function buildAdminViewConfigEntry(adminViewSlug, source) {
         `\t\tfile: ${quoteTsString(`src/admin-views/${adminViewSlug}/index.tsx`)},`,
         `\t\tphpFile: ${quoteTsString(`inc/admin-views/${adminViewSlug}.php`)},`,
         `\t\tslug: ${quoteTsString(adminViewSlug)},`,
-        source ? `\t\tsource: ${quoteTsString(`${source.kind}:${source.slug}`)},` : null,
+        source
+            ? `\t\tsource: ${quoteTsString(formatAdminViewSourceLocator(source))},`
+            : null,
         "\t},",
     ]
         .filter((line) => typeof line === "string")
@@ -109,8 +185,12 @@ function buildAdminViewRegistrySource(adminViewSlugs) {
         .join("\n");
     return `${importLines}${importLines ? "\n\n" : ""}// wp-typia add admin-view entries\n`;
 }
-function buildAdminViewTypesSource(adminViewSlug, restResource) {
+/**
+ * Build the generated admin-view item and dataset types for the selected source.
+ */
+function buildAdminViewTypesSource(adminViewSlug, restResource, coreDataSource) {
     const pascalName = toPascalCase(adminViewSlug);
+    const coreDataRecordTypeName = `${pascalName}CoreDataRecord`;
     const itemTypeName = `${pascalName}AdminViewItem`;
     const dataSetTypeName = `${pascalName}AdminViewDataSet`;
     if (restResource) {
@@ -120,6 +200,74 @@ function buildAdminViewTypesSource(adminViewSlug, restResource) {
 
 export type ${itemTypeName} = ${restPascalName}Record;
 
+export interface ${dataSetTypeName} {
+\titems: ${itemTypeName}[];
+\tpaginationInfo: {
+\t\ttotalItems: number;
+\t\ttotalPages: number;
+\t};
+}
+`;
+    }
+    if (coreDataSource) {
+        if (coreDataSource.entityKind === "taxonomy") {
+            return `export interface ${coreDataRecordTypeName} {
+\tcount?: number;
+\tdescription?: string;
+\tid: number;
+\tlink?: string;
+\tmeta?: Record<string, unknown>;
+\tname?: string;
+\tparent?: number;
+\tslug?: string;
+\ttaxonomy?: string;
+\t[key: string]: unknown;
+}
+
+export interface ${itemTypeName} {
+\tcount: number;
+\tdescription: string;
+\tid: number;
+\tlink: string;
+\tname: string;
+\tparent: number;
+\traw: ${coreDataRecordTypeName};
+\tslug: string;
+\ttaxonomy: string;
+}
+
+export interface ${dataSetTypeName} {
+\titems: ${itemTypeName}[];
+\tpaginationInfo: {
+\t\ttotalItems: number;
+\t\ttotalPages: number;
+\t};
+}
+`;
+        }
+        return `export interface ${coreDataRecordTypeName} {
+\tid: number;
+\tdate?: string;
+\tmodified?: string;
+\tname?: string;
+\tslug?: string;
+\tstatus?: string;
+\ttitle?: string | {
+\t\traw?: string;
+\t\trendered?: string;
+\t};
+\t[key: string]: unknown;
+}
+
+export interface ${itemTypeName} {
+\tid: number;
+\traw: ${coreDataRecordTypeName};
+\tslug: string;
+\tstatus: string;
+\ttitle: string;
+\tupdatedAt: string;
+}
+
 export interface ${dataSetTypeName} {
 \titems: ${itemTypeName}[];
 \tpaginationInfo: {
@@ -148,19 +296,37 @@ export interface ${dataSetTypeName} {
 }
 `;
 }
-function buildAdminViewConfigSource(adminViewSlug, textDomain, restResource) {
+/**
+ * Build the generated DataViews config source for an admin-view scaffold.
+ */
+function buildAdminViewConfigSource(adminViewSlug, textDomain, source, restResource) {
     const pascalName = toPascalCase(adminViewSlug);
     const camelName = toCamelCase(adminViewSlug);
     const itemTypeName = `${pascalName}AdminViewItem`;
     const dataViewsName = `${camelName}AdminDataViews`;
+    const isCoreDataSource = source?.kind === ADMIN_VIEW_CORE_DATA_SOURCE_KIND;
+    const isTaxonomyCoreDataSource = source?.kind === ADMIN_VIEW_CORE_DATA_SOURCE_KIND &&
+        source.entityKind === "taxonomy";
     const defaultViewFields = restResource
         ? "['id']"
-        : "['title', 'status', 'updatedAt']";
+        : isTaxonomyCoreDataSource
+            ? "['name', 'slug', 'count']"
+            : isCoreDataSource
+                ? "['title', 'slug', 'status', 'updatedAt']"
+                : "['title', 'status', 'updatedAt']";
     const searchEnabled = restResource ? "false" : "true";
-    const titleFieldSource = restResource ? "" : "\ttitleField: 'title',\n";
+    const titleFieldSource = restResource
+        ? ""
+        : isTaxonomyCoreDataSource
+            ? "\ttitleField: 'name',\n"
+            : "\ttitleField: 'title',\n";
     const defaultViewEnhancementsSource = restResource
         ? ""
-        : `\t\tsort: {
+        : isTaxonomyCoreDataSource
+            ? "\t\ttitleField: 'name',\n"
+            : isCoreDataSource
+                ? "\t\ttitleField: 'title',\n"
+                : `\t\tsort: {
 \t\t\tdirection: 'desc',
 \t\t\tfield: 'updatedAt',
 \t\t},
@@ -168,7 +334,58 @@ function buildAdminViewConfigSource(adminViewSlug, textDomain, restResource) {
 `;
     const additionalFieldsSource = restResource
         ? "\t\t// REST-backed screens start with the guaranteed ID column. Add project-owned fields here once they are declared on the REST record type."
-        : `\t\towner: {
+        : isTaxonomyCoreDataSource
+            ? `\t\tcount: {
+\t\t\tlabel: __( 'Count', ${quoteTsString(textDomain)} ),
+\t\t\tschema: { type: 'integer' },
+\t\t},
+\t\tdescription: {
+\t\t\tlabel: __( 'Description', ${quoteTsString(textDomain)} ),
+\t\t\tschema: { type: 'string' },
+\t\t},
+\t\tlink: {
+\t\t\tlabel: __( 'Link', ${quoteTsString(textDomain)} ),
+\t\t\tschema: { format: 'uri', type: 'string' },
+\t\t},
+\t\tname: {
+\t\t\tenableGlobalSearch: true,
+\t\t\tlabel: __( 'Name', ${quoteTsString(textDomain)} ),
+\t\t\tschema: { type: 'string' },
+\t\t},
+\t\tparent: {
+\t\t\tlabel: __( 'Parent', ${quoteTsString(textDomain)} ),
+\t\t\tschema: { type: 'integer' },
+\t\t},
+\t\tslug: {
+\t\t\tenableGlobalSearch: true,
+\t\t\tlabel: __( 'Slug', ${quoteTsString(textDomain)} ),
+\t\t\tschema: { type: 'string' },
+\t\t},
+\t\ttaxonomy: {
+\t\t\tlabel: __( 'Taxonomy', ${quoteTsString(textDomain)} ),
+\t\t\tschema: { type: 'string' },
+\t\t},`
+            : isCoreDataSource
+                ? `\t\tslug: {
+\t\t\tenableGlobalSearch: true,
+\t\t\tlabel: __( 'Slug', ${quoteTsString(textDomain)} ),
+\t\t\tschema: { type: 'string' },
+\t\t},
+\t\tstatus: {
+\t\t\tlabel: __( 'Status', ${quoteTsString(textDomain)} ),
+\t\t\tschema: { type: 'string' },
+\t\t},
+\t\ttitle: {
+\t\t\tenableGlobalSearch: true,
+\t\t\tlabel: __( 'Name', ${quoteTsString(textDomain)} ),
+\t\t\tschema: { type: 'string' },
+\t\t},
+\t\tupdatedAt: {
+\t\t\tlabel: __( 'Updated', ${quoteTsString(textDomain)} ),
+\t\t\tschema: { format: 'date-time', type: 'string' },
+\t\t\ttype: 'datetime',
+\t\t},`
+                : `\t\towner: {
 \t\t\tlabel: __( 'Owner', ${quoteTsString(textDomain)} ),
 \t\t\tschema: { type: 'string' },
 \t\t},
@@ -355,6 +572,220 @@ export async function ${fetchName}(
 }
 `;
 }
+/**
+ * Build a core-data-backed admin-view data module for a supported entity family.
+ */
+function buildCoreDataAdminViewDataSource(adminViewSlug, coreDataSource) {
+    const pascalName = toPascalCase(adminViewSlug);
+    const camelName = toCamelCase(adminViewSlug);
+    const coreDataRecordTypeName = `${pascalName}CoreDataRecord`;
+    const dataSetTypeName = `${pascalName}AdminViewDataSet`;
+    const itemTypeName = `${pascalName}AdminViewItem`;
+    const queryTypeName = `${pascalName}AdminViewQuery`;
+    const dataViewsName = `${camelName}AdminDataViews`;
+    const useEntityRecordName = `use${pascalName}EntityRecord`;
+    const useEntityRecordsName = `use${pascalName}EntityRecords`;
+    const useAdminViewDataName = `use${pascalName}AdminViewData`;
+    if (coreDataSource.entityKind === "taxonomy") {
+        return `import type { DataViewsView } from '@wp-typia/dataviews';
+import { useEntityRecord, useEntityRecords } from '@wordpress/core-data';
+import { useMemo } from '@wordpress/element';
+
+import { ${dataViewsName} } from './config';
+import type {
+\t${coreDataRecordTypeName},
+\t${dataSetTypeName},
+\t${itemTypeName},
+} from './types';
+
+export interface ${queryTypeName} {
+\tpage?: number;
+\tper_page?: number;
+\tsearch?: string;
+}
+
+const CORE_DATA_ENTITY_KIND = ${quoteTsString(coreDataSource.entityKind)};
+const CORE_DATA_ENTITY_NAME = ${quoteTsString(coreDataSource.entityName)};
+
+function normalizeCoreDataNumber(value: unknown): number {
+\treturn typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+
+function normalizeCoreDataString(value: unknown): string {
+\treturn typeof value === 'string' ? value : '';
+}
+
+function normalizeTaxonomyRecord(record: ${coreDataRecordTypeName}): ${itemTypeName} {
+\treturn {
+\t\tcount: normalizeCoreDataNumber(record.count),
+\t\tdescription: normalizeCoreDataString(record.description),
+\t\tid: record.id,
+\t\tlink: normalizeCoreDataString(record.link),
+\t\tname: normalizeCoreDataString(record.name) || normalizeCoreDataString(record.slug),
+\t\tparent: normalizeCoreDataNumber(record.parent),
+\t\traw: record,
+\t\tslug: normalizeCoreDataString(record.slug),
+\t\ttaxonomy: normalizeCoreDataString(record.taxonomy),
+\t};
+\t}
+
+export function ${useEntityRecordName}(recordId: number | undefined) {
+\treturn useEntityRecord<${coreDataRecordTypeName}>(
+\t\tCORE_DATA_ENTITY_KIND,
+\t\tCORE_DATA_ENTITY_NAME,
+\t\trecordId ?? 0,
+\t\t{ enabled: typeof recordId === 'number' },
+\t);
+\t}
+
+export function ${useEntityRecordsName}(view: DataViewsView<${itemTypeName}>) {
+\tconst query = ${dataViewsName}.toQueryArgs<${queryTypeName}>(view, {
+\t\tperPageParam: 'per_page',
+\t});
+
+\treturn useEntityRecords<${coreDataRecordTypeName}>(
+\t\tCORE_DATA_ENTITY_KIND,
+\t\tCORE_DATA_ENTITY_NAME,
+\t\tquery,
+\t);
+\t}
+
+export function ${useAdminViewDataName}(view: DataViewsView<${itemTypeName}>) {
+\tconst { hasResolved, isResolving, records, totalItems, totalPages } =
+\t\t${useEntityRecordsName}(view);
+\tconst items = useMemo(
+\t\t() => (records ?? []).map((record) => normalizeTaxonomyRecord(record)),
+\t\t[records],
+\t);
+\tconst dataSet = useMemo<${dataSetTypeName}>(
+\t\t() => ({
+\t\t\titems,
+\t\t\tpaginationInfo: {
+\t\t\t\ttotalItems: totalItems ?? items.length,
+\t\t\t\ttotalPages: Math.max(1, totalPages ?? 1),
+\t\t\t},
+\t\t}),
+\t\t[items, totalItems, totalPages],
+\t);
+\tconst error =
+\t\t!isResolving && hasResolved && records === null
+\t\t\t? 'Unable to load core-data entity records.'
+\t\t\t: null;
+
+\treturn {
+\t\tdataSet,
+\t\terror,
+\t\tisLoading: isResolving,
+\t};
+\t}
+`;
+    }
+    return `import type { DataViewsView } from '@wp-typia/dataviews';
+import { useEntityRecord, useEntityRecords } from '@wordpress/core-data';
+import { useMemo } from '@wordpress/element';
+
+import { ${dataViewsName} } from './config';
+import type {
+\t${coreDataRecordTypeName},
+\t${dataSetTypeName},
+\t${itemTypeName},
+} from './types';
+
+export interface ${queryTypeName} {
+\tpage?: number;
+\tper_page?: number;
+\tsearch?: string;
+}
+
+const CORE_DATA_ENTITY_KIND = ${quoteTsString(coreDataSource.entityKind)};
+const CORE_DATA_ENTITY_NAME = ${quoteTsString(coreDataSource.entityName)};
+
+function normalizeCoreDataString(value: unknown): string {
+\treturn typeof value === 'string' ? value : '';
+}
+
+function normalizeCoreDataTitle(record: ${coreDataRecordTypeName}): string {
+\tif (typeof record.title === 'string') {
+\t\treturn record.title;
+\t}
+\tif (record.title && typeof record.title === 'object') {
+\t\tif (typeof record.title.rendered === 'string') {
+\t\t\treturn record.title.rendered;
+\t\t}
+\t\tif (typeof record.title.raw === 'string') {
+\t\t\treturn record.title.raw;
+\t\t}
+\t}
+
+\treturn normalizeCoreDataString(record.name) || normalizeCoreDataString(record.slug);
+}
+
+function normalizeCoreDataUpdatedAt(record: ${coreDataRecordTypeName}): string {
+\treturn normalizeCoreDataString(record.modified) || normalizeCoreDataString(record.date);
+}
+
+function normalizeCoreDataRecord(record: ${coreDataRecordTypeName}): ${itemTypeName} {
+\treturn {
+\t\tid: record.id,
+\t\traw: record,
+\t\tslug: normalizeCoreDataString(record.slug),
+\t\tstatus: normalizeCoreDataString(record.status),
+\t\ttitle: normalizeCoreDataTitle(record),
+\t\tupdatedAt: normalizeCoreDataUpdatedAt(record),
+\t};
+}
+
+export function ${useEntityRecordName}(recordId: number | undefined) {
+\treturn useEntityRecord<${coreDataRecordTypeName}>(
+\t\tCORE_DATA_ENTITY_KIND,
+\t\tCORE_DATA_ENTITY_NAME,
+\t\trecordId ?? 0,
+\t\t{ enabled: typeof recordId === 'number' },
+\t);
+}
+
+export function ${useEntityRecordsName}(view: DataViewsView<${itemTypeName}>) {
+\tconst query = ${dataViewsName}.toQueryArgs<${queryTypeName}>(view, {
+\t\tperPageParam: 'per_page',
+\t});
+
+\treturn useEntityRecords<${coreDataRecordTypeName}>(
+\t\tCORE_DATA_ENTITY_KIND,
+\t\tCORE_DATA_ENTITY_NAME,
+\t\tquery,
+\t);
+}
+
+export function ${useAdminViewDataName}(view: DataViewsView<${itemTypeName}>) {
+\tconst { hasResolved, isResolving, records, totalItems, totalPages } =
+\t\t${useEntityRecordsName}(view);
+\tconst items = useMemo(
+\t\t() => (records ?? []).map((record) => normalizeCoreDataRecord(record)),
+\t\t[records],
+\t);
+\tconst dataSet = useMemo<${dataSetTypeName}>(
+\t\t() => ({
+\t\t\titems,
+\t\t\tpaginationInfo: {
+\t\t\t\ttotalItems: totalItems ?? items.length,
+\t\t\t\ttotalPages: Math.max(1, totalPages ?? 1),
+\t\t\t},
+\t\t}),
+\t\t[items, totalItems, totalPages],
+\t);
+\tconst error =
+\t\t!isResolving && hasResolved && records === null
+\t\t\t? 'Unable to load core-data entity records.'
+\t\t\t: null;
+
+\treturn {
+\t\tdataSet,
+\t\terror,
+\t\tisLoading: isResolving,
+\t};
+}
+`;
+}
 function buildAdminViewScreenSource(adminViewSlug, textDomain) {
     const pascalName = toPascalCase(adminViewSlug);
     const camelName = toCamelCase(adminViewSlug);
@@ -468,6 +899,81 @@ export function ${componentName}() {
 }
 `;
 }
+function buildCoreDataAdminViewScreenSource(adminViewSlug, textDomain) {
+    const pascalName = toPascalCase(adminViewSlug);
+    const camelName = toCamelCase(adminViewSlug);
+    const itemTypeName = `${pascalName}AdminViewItem`;
+    const dataSetTypeName = `${pascalName}AdminViewDataSet`;
+    const componentName = `${pascalName}AdminViewScreen`;
+    const dataViewsName = `${camelName}AdminDataViews`;
+    const useAdminViewDataName = `use${pascalName}AdminViewData`;
+    const title = toTitleCase(adminViewSlug);
+    return `import type { DataViewsConfig, DataViewsView } from '@wp-typia/dataviews';
+import { Notice, Spinner } from '@wordpress/components';
+import { useState } from '@wordpress/element';
+import { __ } from '@wordpress/i18n';
+import { DataViews } from '@wordpress/dataviews/wp';
+
+import { ${dataViewsName} } from './config';
+import { ${useAdminViewDataName} } from './data';
+import type { ${dataSetTypeName}, ${itemTypeName} } from './types';
+
+const TypedDataViews = DataViews as unknown as <TItem extends object>(
+\tprops: DataViewsConfig<TItem>,
+) => ReturnType<typeof DataViews>;
+
+const EMPTY_DATA_SET: ${dataSetTypeName} = {
+\titems: [],
+\tpaginationInfo: {
+\t\ttotalItems: 0,
+\t\ttotalPages: 1,
+\t},
+};
+
+export function ${componentName}() {
+\tconst [view, setView] = useState<DataViewsView<${itemTypeName}>>(
+\t\t${dataViewsName}.defaultView,
+\t);
+\tconst {
+\t\tdataSet = EMPTY_DATA_SET,
+\t\terror,
+\t\tisLoading,
+\t} = ${useAdminViewDataName}(view);
+\tconst config = ${dataViewsName}.createConfig({
+\t\tdata: dataSet.items,
+\t\tisLoading,
+\t\tonChangeView: setView,
+\t\tpaginationInfo: dataSet.paginationInfo,
+\t\tview,
+\t});
+
+\treturn (
+\t\t<div className="wp-typia-admin-view-screen">
+\t\t\t<header className="wp-typia-admin-view-screen__header">
+\t\t\t\t<div>
+\t\t\t\t\t<p className="wp-typia-admin-view-screen__eyebrow">
+\t\t\t\t\t\t{ __( 'DataViews admin screen', ${quoteTsString(textDomain)} ) }
+\t\t\t\t\t</p>
+\t\t\t\t\t<h1>{ __( ${quoteTsString(title)}, ${quoteTsString(textDomain)} ) }</h1>
+\t\t\t\t\t<p>
+\t\t\t\t\t\t{ __( 'This screen reads from the WordPress core-data entity store. Extend data.ts when you need entity-specific field mapping or edit flows.', ${quoteTsString(textDomain)} ) }
+\t\t\t\t\t</p>
+\t\t\t\t</div>
+\t\t\t\t<div className="wp-typia-admin-view-screen__actions">
+\t\t\t\t\t{ isLoading ? <Spinner /> : null }
+\t\t\t\t</div>
+\t\t\t</header>
+\t\t\t{ error ? (
+\t\t\t\t<Notice isDismissible={ false } status="error">
+\t\t\t\t\t{ error }
+\t\t\t\t</Notice>
+\t\t\t) : null }
+\t\t\t<TypedDataViews<${itemTypeName}> { ...config } />
+\t\t</div>
+\t);
+}
+`;
+}
 function buildAdminViewEntrySource(adminViewSlug) {
     const pascalName = toPascalCase(adminViewSlug);
     const componentName = `${pascalName}AdminViewScreen`;
@@ -637,15 +1143,26 @@ add_action( 'admin_menu', '${registerFunctionName}' );
 add_action( 'admin_enqueue_scripts', '${enqueueFunctionName}' );
 `;
 }
-async function ensureAdminViewPackageDependencies(workspace) {
+async function ensureAdminViewPackageDependencies(workspace, adminViewSource) {
     const packageJsonPath = path.join(workspace.projectDir, "package.json");
     const wpTypiaDataViewsVersion = resolvePackageVersionRange("@wp-typia/dataviews", DEFAULT_WP_TYPIA_DATAVIEWS_VERSION, "wp-typia-dataviews");
     const wordpressDataViewsVersion = resolvePackageVersionRange("@wordpress/dataviews", DEFAULT_WORDPRESS_DATAVIEWS_VERSION);
+    const wordpressCoreDataVersion = resolvePackageVersionRange("@wordpress/core-data", DEFAULT_WORDPRESS_CORE_DATA_VERSION);
+    const wordpressDataVersion = resolvePackageVersionRange("@wordpress/data", DEFAULT_WORDPRESS_DATA_VERSION);
     await patchFile(packageJsonPath, (source) => {
         const packageJson = JSON.parse(source);
+        const coreDataDependencies = isAdminViewCoreDataSource(adminViewSource)
+            ? {
+                "@wordpress/core-data": packageJson.dependencies?.["@wordpress/core-data"] ??
+                    wordpressCoreDataVersion,
+                "@wordpress/data": packageJson.dependencies?.["@wordpress/data"] ??
+                    wordpressDataVersion,
+            }
+            : {};
         const nextDependencies = {
             ...(packageJson.dependencies ?? {}),
             "@wordpress/dataviews": packageJson.dependencies?.["@wordpress/dataviews"] ?? wordpressDataViewsVersion,
+            ...coreDataDependencies,
         };
         const nextDevDependencies = {
             ...(packageJson.devDependencies ?? {}),
@@ -806,6 +1323,8 @@ async function writeAdminViewRegistry(projectDir, adminViewSlug) {
  * Defaults to `process.cwd()`.
  * @param options.source Optional data source locator. `rest-resource:<slug>`
  * wires the screen to an existing list-capable REST resource.
+ * `core-data:<kind>/<name>` binds the screen to a supported WordPress-owned
+ * core-data entity collection.
  * @returns A promise that resolves with the normalized `adminViewSlug`, optional
  * `source`, and owning `projectDir` after scaffold files and inventory entries
  * are written successfully.
@@ -814,10 +1333,14 @@ async function writeAdminViewRegistry(projectDir, adminViewSlug) {
  */
 export async function runAddAdminViewCommand({ adminViewName, cwd = process.cwd(), source, }) {
     const workspace = resolveWorkspaceProject(cwd);
-    const adminViewSlug = assertValidGeneratedSlug("Admin view name", normalizeBlockSlug(adminViewName), "wp-typia add admin-view <name> [--source rest-resource:<slug>]");
+    assertAdminViewPackageAvailability();
+    const adminViewSlug = assertValidGeneratedSlug("Admin view name", normalizeBlockSlug(adminViewName), "wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>]");
     const parsedSource = parseAdminViewSource(source);
     const inventory = readWorkspaceInventory(workspace.projectDir);
     const restResource = resolveRestResourceSource(inventory.restResources, parsedSource);
+    const coreDataSource = isAdminViewCoreDataSource(parsedSource)
+        ? parsedSource
+        : undefined;
     assertAdminViewDoesNotExist(workspace.projectDir, adminViewSlug, inventory);
     const blockConfigPath = path.join(workspace.projectDir, "scripts", "block-config.ts");
     const bootstrapPath = getWorkspaceBootstrapPath(workspace);
@@ -842,16 +1365,20 @@ export async function runAddAdminViewCommand({ adminViewName, cwd = process.cwd(
     try {
         await fsp.mkdir(adminViewDir, { recursive: true });
         await fsp.mkdir(path.dirname(adminViewPhpPath), { recursive: true });
-        await ensureAdminViewPackageDependencies(workspace);
+        await ensureAdminViewPackageDependencies(workspace, parsedSource);
         await ensureAdminViewBootstrapAnchors(workspace);
         await ensureAdminViewBuildScriptAnchors(workspace);
         await ensureAdminViewWebpackAnchors(workspace);
-        await fsp.writeFile(path.join(adminViewDir, "types.ts"), buildAdminViewTypesSource(adminViewSlug, restResource), "utf8");
-        await fsp.writeFile(path.join(adminViewDir, "config.ts"), buildAdminViewConfigSource(adminViewSlug, workspace.workspace.textDomain, restResource), "utf8");
-        await fsp.writeFile(path.join(adminViewDir, "data.ts"), restResource
-            ? buildRestAdminViewDataSource(adminViewSlug, restResource)
-            : buildDefaultAdminViewDataSource(adminViewSlug), "utf8");
-        await fsp.writeFile(path.join(adminViewDir, "Screen.tsx"), buildAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain), "utf8");
+        await fsp.writeFile(path.join(adminViewDir, "types.ts"), buildAdminViewTypesSource(adminViewSlug, restResource, coreDataSource), "utf8");
+        await fsp.writeFile(path.join(adminViewDir, "config.ts"), buildAdminViewConfigSource(adminViewSlug, workspace.workspace.textDomain, parsedSource, restResource), "utf8");
+        await fsp.writeFile(path.join(adminViewDir, "data.ts"), coreDataSource
+            ? buildCoreDataAdminViewDataSource(adminViewSlug, coreDataSource)
+            : restResource
+                ? buildRestAdminViewDataSource(adminViewSlug, restResource)
+                : buildDefaultAdminViewDataSource(adminViewSlug), "utf8");
+        await fsp.writeFile(path.join(adminViewDir, "Screen.tsx"), coreDataSource
+            ? buildCoreDataAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain)
+            : buildAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain), "utf8");
         await fsp.writeFile(path.join(adminViewDir, "index.tsx"), buildAdminViewEntrySource(adminViewSlug), "utf8");
         await fsp.writeFile(path.join(adminViewDir, "style.scss"), buildAdminViewStyleSource(), "utf8");
         await fsp.writeFile(adminViewPhpPath, buildAdminViewPhpSource(adminViewSlug, workspace), "utf8");
@@ -862,7 +1389,9 @@ export async function runAddAdminViewCommand({ adminViewName, cwd = process.cwd(
         return {
             adminViewSlug,
             projectDir: workspace.projectDir,
-            source: parsedSource ? `${parsedSource.kind}:${parsedSource.slug}` : undefined,
+            source: parsedSource
+                ? formatAdminViewSourceLocator(parsedSource)
+                : undefined,
         };
     }
     catch (error) {